Guía de Desarrollo Móvil: React Native, Flutter, Swift, Kotlin y Estrategias Cross-Platform

Building mobile apps in 2026 means choosing between native development (Swift/Kotlin) and cross-platform frameworks (React Native/Flutter). This comprehensive guide covers everything from fundamentals to production deployment, helping you make the right technology choice and build performant, maintainable mobile applications.

Key Takeaways

• React Native is ideal for teams with JavaScript expertise and apps requiring native look-and-feel per platform.
• Flutter provides the most consistent cross-platform UI with a single codebase and excellent hot reload.
• Swift/SwiftUI is the best choice for iOS-only apps needing deep Apple ecosystem integration.
• Kotlin/Jetpack Compose is the modern Android standard with first-class Google support.
• State management choice (Redux, MobX, Provider, Riverpod) significantly impacts app architecture and maintainability.
• Mobile CI/CD with Fastlane, App Center, or CodePush reduces release friction and deployment errors.
• Offline-first architecture and push notifications are essential for modern mobile user experience.
• App Store Optimization (ASO) is as important as code quality for app success.

1. React Native Fundamentals

React Native lets you build mobile apps using JavaScript and React. It renders native components rather than webviews, providing near-native performance and platform-authentic UI. With the New Architecture (Fabric renderer and TurboModules), React Native closes the performance gap with native development significantly.

JSX Components and Hooks

React Native uses the same component model as React web. Core components like View, Text, ScrollView, and FlatList map to native platform views. Hooks like useState, useEffect, and useMemo manage state and side effects.

import React, { useState, useEffect } from 'react';
import { View, Text, FlatList, TouchableOpacity, StyleSheet } from 'react-native';

interface User {
  id: string;
  name: string;
  email: string;
}

export default function UserList() {
  const [users, setUsers] = useState<User[]>([]);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    fetch('https://api.example.com/users')
      .then(res => res.json())
      .then(data => {
        setUsers(data);
        setLoading(false);
      });
  }, []);

  const renderItem = ({ item }: { item: User }) => (
    <TouchableOpacity style={styles.card}>
      <Text style={styles.name}>{item.name}</Text>
      <Text style={styles.email}>{item.email}</Text>
    </TouchableOpacity>
  );

  return (
    <FlatList
      data={users}
      renderItem={renderItem}
      keyExtractor={item => item.id}
      refreshing={loading}
      onRefresh={() => setLoading(true)}
    />
  );
}

Navigation with React Navigation

React Navigation is the de facto routing library for React Native. It supports stack, tab, drawer, and modal navigation patterns with native-feeling transitions and gesture handling.

import { NavigationContainer } from '@react-navigation/native';
import { createNativeStackNavigator } from '@react-navigation/native-stack';
import { createBottomTabNavigator } from '@react-navigation/bottom-tabs';

type RootStackParamList = {
  Home: undefined;
  Profile: { userId: string };
  Settings: undefined;
};

const Stack = createNativeStackNavigator<RootStackParamList>();
const Tab = createBottomTabNavigator();

function HomeTabs() {
  return (
    <Tab.Navigator screenOptions={{ headerShown: false }}>
      <Tab.Screen name="Feed" component={FeedScreen} />
      <Tab.Screen name="Search" component={SearchScreen} />
      <Tab.Screen name="Profile" component={ProfileScreen} />
    </Tab.Navigator>
  );
}

export default function App() {
  return (
    <NavigationContainer>
      <Stack.Navigator>
        <Stack.Screen name="Home" component={HomeTabs} />
        <Stack.Screen name="Profile" component={ProfileDetail} />
        <Stack.Screen name="Settings" component={SettingsScreen} />
      </Stack.Navigator>
    </NavigationContainer>
  );
}

2. Flutter and Dart Basics

Flutter uses Dart and a custom rendering engine (Skia/Impeller) to draw every pixel on screen, giving you complete control over the UI. This approach ensures pixel-perfect consistency across iOS and Android while achieving 60/120fps performance.

Widget Tree and Composition

Everything in Flutter is a widget. The framework uses a declarative UI model where you compose small, reusable widgets into complex layouts. Stateless widgets are pure functions of their configuration, while Stateful widgets manage mutable state.

import 'package:flutter/material.dart';

class UserListScreen extends StatefulWidget {
  const UserListScreen({super.key});

  @override
  State<UserListScreen> createState() => _UserListScreenState();
}

class _UserListScreenState extends State<UserListScreen> {
  List<User> _users = [];
  bool _loading = true;

  @override
  void initState() {
    super.initState();
    _fetchUsers();
  }

  Future<void> _fetchUsers() async {
    final response = await http.get(
      Uri.parse('https://api.example.com/users'),
    );
    setState(() {
      _users = User.fromJsonList(jsonDecode(response.body));
      _loading = false;
    });
  }

  @override
  Widget build(BuildContext context) {
    if (_loading) return const Center(child: CircularProgressIndicator());
    return ListView.builder(
      itemCount: _users.length,
      itemBuilder: (context, index) => UserCard(user: _users[index]),
    );
  }
}

State Management with Riverpod

Riverpod is the recommended state management solution for Flutter, offering compile-safe providers, automatic disposal, and excellent testability. It replaces the older Provider package with a more robust API.

import 'package:flutter_riverpod/flutter_riverpod.dart';

// Define a provider
final usersProvider = FutureProvider<List<User>>((ref) async {
  final repository = ref.watch(userRepositoryProvider);
  return repository.fetchUsers();
});

// Consume in a widget
class UserListScreen extends ConsumerWidget {
  const UserListScreen({super.key});

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final usersAsync = ref.watch(usersProvider);

    return usersAsync.when(
      data: (users) => ListView.builder(
        itemCount: users.length,
        itemBuilder: (_, i) => UserCard(user: users[i]),
      ),
      loading: () => const Center(child: CircularProgressIndicator()),
      error: (err, stack) => Center(child: Text('Error: \$err')),
    );
  }
}

3. Swift and SwiftUI for iOS

Swift with SwiftUI is Apple's modern declarative framework for building iOS, macOS, watchOS, and tvOS apps. SwiftUI provides a reactive data-driven UI with automatic state management, live previews in Xcode, and deep integration with Apple platform features.

SwiftUI Views and Modifiers

SwiftUI uses a modifier chain pattern where views are built by stacking modifiers. State properties marked with @State, @Binding, @ObservedObject, and @EnvironmentObject automatically trigger UI updates when changed.

import SwiftUI

struct UserListView: View {
    @StateObject private var viewModel = UserViewModel()
    @State private var searchText = ""

    var filteredUsers: [User] {
        if searchText.isEmpty { return viewModel.users }
        return viewModel.users.filter {
            $0.name.localizedCaseInsensitiveContains(searchText)
        }
    }

    var body: some View {
        NavigationStack {
            List(filteredUsers) { user in
                NavigationLink(value: user) {
                    UserRow(user: user)
                }
            }
            .navigationTitle("Users")
            .searchable(text: $searchText)
            .refreshable { await viewModel.fetchUsers() }
            .navigationDestination(for: User.self) { user in
                UserDetailView(user: user)
            }
        }
    }
}

@Observable
class UserViewModel {
    var users: [User] = []
    var isLoading = false

    func fetchUsers() async {
        isLoading = true
        defer { isLoading = false }
        let (data, _) = try await URLSession.shared.data(
            from: URL(string: "https://api.example.com/users")!
        )
        users = try JSONDecoder().decode([User].self, from: data)
    }
}

Combining SwiftUI with UIKit

You can embed UIKit views in SwiftUI using UIViewRepresentable and SwiftUI views in UIKit with UIHostingController. This enables gradual migration of existing apps.

// Embedding UIKit in SwiftUI
struct MapView: UIViewRepresentable {
    @Binding var region: MKCoordinateRegion

    func makeUIView(context: Context) -> MKMapView {
        let mapView = MKMapView()
        mapView.delegate = context.coordinator
        return mapView
    }

    func updateUIView(_ mapView: MKMapView, context: Context) {
        mapView.setRegion(region, animated: true)
    }

    func makeCoordinator() -> Coordinator {
        Coordinator(self)
    }
}

// Embedding SwiftUI in UIKit
let hostingController = UIHostingController(
    rootView: UserListView()
)
navigationController?.pushViewController(
    hostingController, animated: true
)

4. Kotlin and Jetpack Compose for Android

Kotlin with Jetpack Compose is the modern Android UI toolkit, replacing XML layouts with a declarative Kotlin-based approach. Compose integrates seamlessly with the existing Android ecosystem, Kotlin coroutines, and Jetpack libraries.

Composable Functions

In Jetpack Compose, UI elements are defined as composable functions annotated with @Composable. State is managed with remember and mutableStateOf, triggering automatic recomposition when values change.

@Composable
fun UserListScreen(
    viewModel: UserViewModel = hiltViewModel()
) {
    val uiState by viewModel.uiState.collectAsStateWithLifecycle()

    when (val state = uiState) {
        is UiState.Loading -> {
            Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
                CircularProgressIndicator()
            }
        }
        is UiState.Success -> {
            LazyColumn(
                contentPadding = PaddingValues(16.dp),
                verticalArrangement = Arrangement.spacedBy(8.dp)
            ) {
                items(state.users, key = { it.id }) { user ->
                    UserCard(
                        user = user,
                        onClick = { viewModel.onUserClicked(user.id) }
                    )
                }
            }
        }
        is UiState.Error -> {
            ErrorScreen(
                message = state.message,
                onRetry = { viewModel.retry() }
            )
        }
    }
}

ViewModel and State Hoisting

Android's ViewModel survives configuration changes and pairs with Compose's state hoisting pattern. State is lifted to the ViewModel layer while the UI layer remains a pure function of that state.

@HiltViewModel
class UserViewModel @Inject constructor(
    private val repository: UserRepository
) : ViewModel() {

    private val _uiState = MutableStateFlow<UiState>(UiState.Loading)
    val uiState: StateFlow<UiState> = _uiState.asStateFlow()

    init { loadUsers() }

    private fun loadUsers() {
        viewModelScope.launch {
            _uiState.value = UiState.Loading
            repository.getUsers()
                .onSuccess { users ->
                    _uiState.value = UiState.Success(users)
                }
                .onFailure { error ->
                    _uiState.value = UiState.Error(error.message ?: "Unknown")
                }
        }
    }

    fun retry() = loadUsers()
}

sealed interface UiState {
    data object Loading : UiState
    data class Success(val users: List<User>) : UiState
    data class Error(val message: String) : UiState
}

5. Cross-Platform Framework Comparison

Choosing between React Native, Flutter, native iOS, and native Android depends on your team's skills, project requirements, budget, and timeline. Here is a detailed comparison across key dimensions.

6. Performance Optimization

Mobile performance directly impacts user retention. Apps that take more than 3 seconds to load lose 53% of users. Here are battle-tested optimization techniques for each framework.

Lazy Loading and Virtualized Lists

Never render all items at once. Use FlatList in React Native, ListView.builder in Flutter, LazyVStack in SwiftUI, or LazyColumn in Compose to render only visible items.

// React Native — Optimized FlatList
<FlatList
  data={items}
  renderItem={renderItem}
  keyExtractor={item => item.id}
  initialNumToRender={10}
  maxToRenderPerBatch={5}
  windowSize={5}
  removeClippedSubviews={true}
  getItemLayout={(data, index) => ({
    length: ITEM_HEIGHT,
    offset: ITEM_HEIGHT * index,
    index,
  })}
/>

// Flutter — ListView.builder with const widgets
ListView.builder(
  itemCount: items.length,
  itemExtent: 72.0,  // fixed height for performance
  itemBuilder: (context, index) {
    return ItemCard(key: ValueKey(items[index].id), item: items[index]);
  },
)

Image Caching and Optimization

Images are the largest assets in most mobile apps. Use libraries like react-native-fast-image, cached_network_image (Flutter), Kingfisher (iOS), or Coil (Android) for efficient caching, progressive loading, and format optimization.

// React Native — FastImage with caching
import FastImage from 'react-native-fast-image';

<FastImage
  source={{
    uri: 'https://example.com/photo.jpg',
    priority: FastImage.priority.normal,
    cache: FastImage.cacheControl.immutable,
  }}
  resizeMode={FastImage.resizeMode.cover}
  style={{ width: 200, height: 200 }}
/>

// Flutter — CachedNetworkImage
CachedNetworkImage(
  imageUrl: "https://example.com/photo.jpg",
  placeholder: (context, url) => const CircularProgressIndicator(),
  errorWidget: (context, url, error) => const Icon(Icons.error),
  memCacheWidth: 400,  // limit memory cache size
)

Memory Management

Memory leaks are a common cause of mobile app crashes. Monitor memory usage with platform profilers, dispose of controllers and subscriptions properly, and avoid retaining large objects in global state.

// React Native — Cleanup subscriptions
useEffect(() => {
  const subscription = eventEmitter.addListener('update', handler);
  return () => subscription.remove();  // ALWAYS clean up
}, []);

// Flutter — Dispose controllers
class _MyWidgetState extends State<MyWidget> {
  late final ScrollController _scrollController;
  late final StreamSubscription _subscription;

  @override
  void initState() {
    super.initState();
    _scrollController = ScrollController();
    _subscription = stream.listen((_) { /* handle */ });
  }

  @override
  void dispose() {
    _scrollController.dispose();
    _subscription.cancel();
    super.dispose();  // Always call super.dispose() last
  }
}

7. State Management Patterns

State management is the most debated topic in mobile development. The right choice depends on app complexity, team experience, and scalability needs.

React Native: Redux vs MobX vs Zustand

Redux offers predictable state with time-travel debugging but requires boilerplate. MobX provides reactive state with decorators. Zustand is a minimal, hook-based alternative that has gained significant popularity for its simplicity.

// Zustand — Minimal React Native state management
import { create } from 'zustand';
import { persist, createJSONStorage } from 'zustand/middleware';
import AsyncStorage from '@react-native-async-storage/async-storage';

interface AuthStore {
  user: User | null;
  token: string | null;
  login: (email: string, password: string) => Promise<void>;
  logout: () => void;
}

export const useAuthStore = create<AuthStore>()(
  persist(
    (set) => ({
      user: null,
      token: null,
      login: async (email, password) => {
        const response = await api.login(email, password);
        set({ user: response.user, token: response.token });
      },
      logout: () => set({ user: null, token: null }),
    }),
    {
      name: 'auth-storage',
      storage: createJSONStorage(() => AsyncStorage),
    }
  )
);

Flutter: Provider vs Riverpod vs BLoC

Provider is simple but lacks compile-time safety. Riverpod fixes Provider's limitations with global providers and auto-dispose. BLoC (Business Logic Component) uses streams for maximum separation of concerns.

// BLoC Pattern — Streams for separation of concerns
class UserBloc extends Bloc<UserEvent, UserState> {
  final UserRepository _repository;

  UserBloc(this._repository) : super(UserInitial()) {
    on<LoadUsers>(_onLoadUsers);
    on<RefreshUsers>(_onRefreshUsers);
    on<DeleteUser>(_onDeleteUser);
  }

  Future<void> _onLoadUsers(
    LoadUsers event, Emitter<UserState> emit
  ) async {
    emit(UserLoading());
    try {
      final users = await _repository.fetchUsers();
      emit(UserLoaded(users));
    } catch (e) {
      emit(UserError(e.toString()));
    }
  }
}

8. Mobile Testing Strategies

A robust testing strategy combines unit tests, widget/component tests, integration tests, and end-to-end tests. Each layer catches different categories of bugs and has different speed/reliability tradeoffs.

Unit and Component Testing

Use Jest for React Native, flutter_test for Flutter, XCTest for Swift, and JUnit/MockK for Kotlin. Aim for 80%+ code coverage on business logic and state management layers.

// Jest — React Native component test
import { render, fireEvent, waitFor } from '@testing-library/react-native';
import { UserList } from '../UserList';

describe('UserList', () => {
  it('renders users after loading', async () => {
    const mockUsers = [
      { id: '1', name: 'Alice', email: 'alice@test.com' },
      { id: '2', name: 'Bob', email: 'bob@test.com' },
    ];
    jest.spyOn(api, 'fetchUsers').mockResolvedValue(mockUsers);

    const { getByText, queryByTestId } = render(<UserList />);

    // Loading state
    expect(queryByTestId('loading-spinner')).toBeTruthy();

    // Loaded state
    await waitFor(() => {
      expect(getByText('Alice')).toBeTruthy();
      expect(getByText('Bob')).toBeTruthy();
    });
  });

  it('handles pull-to-refresh', async () => {
    const { getByTestId } = render(<UserList />);
    fireEvent(getByTestId('user-list'), 'refresh');
    await waitFor(() => {
      expect(api.fetchUsers).toHaveBeenCalledTimes(2);
    });
  });
});

E2E Testing with Detox and Maestro

Detox runs on real devices with gray-box testing for React Native. Maestro offers a YAML-based declarative approach that works across all frameworks. Both are more reliable than Appium for mobile-specific testing.

# Maestro — Declarative E2E testing (YAML)
# login-flow.yaml
appId: com.myapp.mobile
---
- launchApp
- assertVisible: "Welcome"
- tapOn: "Sign In"
- inputText:
    id: "email-input"
    text: "test@example.com"
- inputText:
    id: "password-input"
    text: "password123"
- tapOn: "Log In"
- assertVisible: "Dashboard"
- scroll
- assertVisible: "Recent Activity"
- takeScreenshot: "dashboard-loaded"

9. CI/CD for Mobile Apps

Mobile CI/CD is more complex than web deployment because of code signing, provisioning profiles, app store review processes, and multiple build targets. Automation is essential for sustainable release cadence.

Fastlane for Automated Builds

Fastlane automates screenshots, beta deployment, code signing, and App Store/Play Store submission. It handles the most painful parts of mobile release management with a Ruby-based DSL.

# Fastfile — Automated iOS and Android builds
default_platform(:ios)

platform :ios do
  desc "Push a new beta build to TestFlight"
  lane :beta do
    increment_build_number(xcodeproj: "MyApp.xcodeproj")
    match(type: "appstore")  # code signing
    build_app(
      workspace: "MyApp.xcworkspace",
      scheme: "MyApp",
      export_method: "app-store"
    )
    upload_to_testflight(skip_waiting_for_build_processing: true)
    slack(message: "iOS beta deployed to TestFlight!")
  end

  desc "Deploy to App Store"
  lane :release do
    beta  # reuse beta lane
    deliver(
      submit_for_review: true,
      automatic_release: true,
      force: true
    )
  end
end

platform :android do
  lane :beta do
    gradle(task: "clean bundleRelease")
    upload_to_play_store(track: "beta")
  end
end

Over-the-Air Updates with CodePush

CodePush (now part of App Center) enables JavaScript bundle updates without going through app store review. This allows you to ship bug fixes and minor features instantly. Note that native code changes still require a full app store release.

// CodePush — Over-the-air JS bundle updates
import codePush from "react-native-code-push";

const codePushOptions = {
  checkFrequency: codePush.CheckFrequency.ON_APP_RESUME,
  installMode: codePush.InstallMode.ON_NEXT_RESTART,
  mandatoryInstallMode: codePush.InstallMode.IMMEDIATE,
};

function App() {
  const [updateAvailable, setUpdateAvailable] = useState(false);

  useEffect(() => {
    codePush.checkForUpdate().then(update => {
      if (update) setUpdateAvailable(true);
    });
  }, []);

  return <MainNavigator />;
}

export default codePush(codePushOptions)(App);

# CLI: Release a CodePush update
# appcenter codepush release-react -a MyOrg/MyApp-iOS -d Production

10. Push Notifications

Push notifications drive 3-10x higher engagement when implemented thoughtfully. Poor implementation leads to uninstalls. The key is relevance, timing, and user control.

Platform Setup

iOS uses APNs (Apple Push Notification service) and Android uses FCM (Firebase Cloud Messaging). Both require server-side infrastructure. Services like Firebase, OneSignal, or AWS SNS abstract the platform differences.

// React Native — Firebase push notifications setup
import messaging from '@react-native-firebase/messaging';
import notifee from '@notifee/react-native';

// Request permission (iOS)
async function requestPermission() {
  const authStatus = await messaging().requestPermission();
  const enabled =
    authStatus === messaging.AuthorizationStatus.AUTHORIZED ||
    authStatus === messaging.AuthorizationStatus.PROVISIONAL;
  if (enabled) {
    const token = await messaging().getToken();
    await api.registerPushToken(token);
  }
}

// Handle foreground messages
messaging().onMessage(async remoteMessage => {
  await notifee.displayNotification({
    title: remoteMessage.notification?.title,
    body: remoteMessage.notification?.body,
    android: {
      channelId: 'default',
      pressAction: { id: 'default' },
    },
  });
});

Notification Channels and Categories

Android 8+ requires notification channels for categorization. iOS supports notification categories with custom actions. Both platforms allow users to control which notification types they receive.

// Android — Notification channel setup (Kotlin)
private fun createNotificationChannels() {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
        val channels = listOf(
            NotificationChannel(
                "messages", "Messages",
                NotificationManager.IMPORTANCE_HIGH
            ).apply {
                description = "New message notifications"
                enableVibration(true)
            },
            NotificationChannel(
                "updates", "App Updates",
                NotificationManager.IMPORTANCE_LOW
            ).apply {
                description = "App update notifications"
            }
        )
        val manager = getSystemService(NotificationManager::class.java)
        manager.createNotificationChannels(channels)
    }
}

11. Offline-First Architecture

Mobile apps must work reliably on flaky networks. An offline-first approach stores data locally and syncs when connectivity is available, providing a seamless user experience regardless of network conditions.

Local Storage Options

SQLite (via Drift, Room, or Core Data) handles structured relational data. Key-value stores like MMKV, Hive, or UserDefaults are faster for simple preferences. For complex sync scenarios, consider CRDTs or operational transforms.

// React Native — Offline-first with WatermelonDB
import { Database } from '@nozbe/watermelondb';
import SQLiteAdapter from '@nozbe/watermelondb/adapters/sqlite';

const adapter = new SQLiteAdapter({
  schema: appSchema,
  migrations: appMigrations,
  jsi: true,  // enable JSI for 3x faster queries
});

const database = new Database({ adapter, modelClasses: [User, Post] });

// Sync with remote server
import { synchronize } from '@nozbe/watermelondb/sync';

async function syncDatabase() {
  await synchronize({
    database,
    pullChanges: async ({ lastPulledAt }) => {
      const response = await api.pullChanges(lastPulledAt);
      return { changes: response.changes, timestamp: response.timestamp };
    },
    pushChanges: async ({ changes }) => {
      await api.pushChanges(changes);
    },
  });
}

Sync Strategies

Implement conflict resolution policies (last-write-wins, merge, or manual). Use background sync with exponential backoff. Queue mutations locally and replay them when online. Provide clear UI indicators for sync status.

// Flutter — Offline queue with Drift (SQLite)
@DriftDatabase(tables: [Users, SyncQueue])
class AppDatabase extends _$AppDatabase {
  AppDatabase() : super(_openConnection());

  @override
  int get schemaVersion => 2;

  // Queue a mutation for background sync
  Future<void> queueMutation(String type, String payload) {
    return into(syncQueue).insert(
      SyncQueueCompanion(
        type: Value(type),
        payload: Value(payload),
        createdAt: Value(DateTime.now()),
        status: const Value('pending'),
      ),
    );
  }

  // Process pending mutations
  Future<void> syncPending() async {
    final pending = await (select(syncQueue)
      ..where((t) => t.status.equals('pending'))
      ..orderBy([(t) => OrderingTerm.asc(t.createdAt)]))
      .get();
    for (final item in pending) {
      await _processMutation(item);
    }
  }
}

12. Deep Linking and App Store Optimization

Deep linking connects web URLs to specific app screens, improving user acquisition and retention. ASO ensures your app is discoverable in crowded app stores.

Universal Links and App Links

iOS Universal Links and Android App Links use HTTPS URLs that open directly in your app. Configure the apple-app-site-association file (iOS) and assetlinks.json (Android) on your domain to enable verified deep linking.

// apple-app-site-association (iOS Universal Links)
{
  "applinks": {
    "apps": [],
    "details": [
      {
        "appID": "TEAM_ID.com.myapp.mobile",
        "paths": [
          "/product/*",
          "/user/*",
          "/share/*"
        ]
      }
    ]
  }
}

// assetlinks.json (Android App Links)
[{
  "relation": ["delegate_permission/common.handle_all_urls"],
  "target": {
    "namespace": "android_app",
    "package_name": "com.myapp.mobile",
    "sha256_cert_fingerprints": ["AA:BB:CC:..."]
  }
}]

// React Native — Handle deep links
const linking = {
  prefixes: ['https://myapp.com', 'myapp://'],
  config: {
    screens: {
      Product: 'product/:id',
      User: 'user/:username',
      Share: 'share/:shareId',
    },
  },
};

<NavigationContainer linking={linking}>
  {/* navigators */}
</NavigationContainer>

App Store Optimization Essentials

ASO factors include app title (30 chars max), subtitle, keywords, screenshots, preview video, ratings, and download velocity. A/B test your store listing regularly. Localize metadata for each target market.

Frequently Asked Questions

Mobile development in 2026 offers more choices and better tooling than ever. Whether you choose cross-platform efficiency or native performance, the fundamentals of good architecture, thorough testing, and user-centric design remain the same. Start with the framework that matches your team's skills, then optimize based on real-world performance data.