Xamarin.Forms

Xamarin.Forms is no longer supported. Migrate your apps to .NET MAUI.

5,634

1,879

5,634

2,441

View on GitHub

Top Related Projects

maui

21,980

.NET MAUI is the .NET Multi-platform App UI, a framework for building native device applications spanning mobile, tablet, and desktop.

flutter

164,677

Flutter makes it easy and fast to build beautiful apps for mobile and beyond

react-native

118,109

A framework for building native applications using React

ionic-framework

50,896

A powerful cross-platform UI toolkit for building native-quality iOS, Android, and Progressive Web Apps with HTML, CSS, and JavaScript.

⚡ Empowering JavaScript with native platform APIs. ✨ Best of all worlds (TypeScript, Swift, Objective C, Kotlin, Java, Dart). Use what you love ❤️ Angular, Capacitor, Ionic, React, Solid, Svelte, Vue with: iOS (UIKit, SwiftUI), Android (View, Jetpack Compose), Dart (Flutter) and you name it compatible.

react-native-windows

16,237

A framework for building native Windows apps with React.

Quick Overview

Xamarin.Forms is an open-source cross-platform UI toolkit that allows developers to create native Android, iOS, and Windows applications using C# and .NET. It provides a single shared codebase for building user interfaces across multiple platforms, significantly reducing development time and effort.

Pros

Cross-platform development with a single codebase
Native UI performance and look-and-feel on each platform
Large community and extensive documentation
Seamless integration with Visual Studio and other .NET technologies

Cons

Steeper learning curve compared to platform-specific development
Limited access to platform-specific features without custom renderers
Larger app size compared to native applications
Performance can be slower than native apps for complex UIs

Code Examples

Creating a simple label:

var label = new Label
{
    Text = "Hello, Xamarin.Forms!",
    HorizontalOptions = LayoutOptions.Center,
    VerticalOptions = LayoutOptions.CenterAndExpand
};

Adding a button with an event handler:

var button = new Button
{
    Text = "Click me!",
    Command = new Command(() => DisplayAlert("Alert", "Button clicked!", "OK"))
};

Creating a list view with data binding:

var listView = new ListView
{
    ItemsSource = new List<string> { "Item 1", "Item 2", "Item 3" },
    ItemTemplate = new DataTemplate(() =>
    {
        var cell = new TextCell();
        cell.SetBinding(TextCell.TextProperty, ".");
        return cell;
    })
};

Getting Started

Install Visual Studio with the Mobile development with .NET workload.
Create a new Xamarin.Forms project in Visual Studio.
Add the following code to your MainPage.xaml.cs file:

public MainPage()
{
    InitializeComponent();
    Content = new StackLayout
    {
        Children = {
            new Label { Text = "Welcome to Xamarin.Forms!", 
                        HorizontalOptions = LayoutOptions.Center,
                        VerticalOptions = LayoutOptions.CenterAndExpand }
        }
    };
}

Build and run the project on your desired platform (Android, iOS, or Windows).

Competitor Comparisons

maui

21,980

.NET MAUI is the .NET Multi-platform App UI, a framework for building native device applications spanning mobile, tablet, and desktop.

Pros of MAUI

Unified development experience across all platforms (iOS, Android, Windows, macOS)
Better performance and smaller app sizes due to .NET 6+ optimizations
Enhanced UI controls and layouts with more customization options

Cons of MAUI

Steeper learning curve for developers new to .NET ecosystem
Less mature ecosystem compared to Xamarin.Forms, with fewer third-party libraries and plugins
Some features and controls from Xamarin.Forms may not be fully implemented yet

Code Comparison

Xamarin.Forms:

public App()
{
    InitializeComponent();
    MainPage = new ContentPage
    {
        Content = new Label { Text = "Hello, Xamarin.Forms!" }
    };
}

MAUI:

public App()
{
    InitializeComponent();
    MainPage = new ContentPage
    {
        Content = new Label { Text = "Hello, .NET MAUI!" }
    };
}

The code structure remains similar, but MAUI offers more advanced features and controls for building modern, cross-platform applications. While the basic setup looks alike, MAUI provides enhanced capabilities for creating rich user interfaces and leveraging platform-specific features more seamlessly.

flutter

164,677

Flutter makes it easy and fast to build beautiful apps for mobile and beyond

Pros of Flutter

Faster development with hot reload feature
Single codebase for multiple platforms (iOS, Android, web, desktop)
Rich set of customizable widgets for consistent UI across platforms

Cons of Flutter

Larger app size due to bundled runtime and libraries
Less mature ecosystem compared to Xamarin.Forms
Steeper learning curve for developers new to Dart language

Code Comparison

Flutter:

import 'package:flutter/material.dart';

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(title: Text('Flutter App')),
        body: Center(child: Text('Hello, World!')),
      ),
    );
  }
}

Xamarin.Forms:

using Xamarin.Forms;

public class App : Application
{
    public App()
    {
        MainPage = new ContentPage
        {
            Content = new Label
            {
                Text = "Hello, World!",
                HorizontalOptions = LayoutOptions.Center,
                VerticalOptions = LayoutOptions.Center
            }
        };
    }
}

Both frameworks offer cross-platform development capabilities, but Flutter provides a more modern approach with its widget-based UI system and hot reload feature. Xamarin.Forms benefits from the mature .NET ecosystem and C# language familiarity for many developers. The choice between the two depends on project requirements, team expertise, and desired app performance.

react-native

118,109

A framework for building native applications using React

Pros of React Native

Larger community and ecosystem, with more third-party libraries and components
Hot reloading for faster development and testing
Better performance for complex UIs and animations

Cons of React Native

Steeper learning curve for developers without JavaScript experience
Less native platform integration compared to Xamarin.Forms
Potential for inconsistent UI across platforms due to reliance on JavaScript

Code Comparison

React Native:

import React from 'react';
import { View, Text, StyleSheet } from 'react-native';

const App = () => (
  <View style={styles.container}>
    <Text>Hello, React Native!</Text>
  </View>
);

Xamarin.Forms:

using Xamarin.Forms;

public class App : Application
{
    public App()
    {
        MainPage = new ContentPage
        {
            Content = new Label { Text = "Hello, Xamarin.Forms!" }
        };
    }
}

Both frameworks allow for cross-platform mobile development, but React Native uses JavaScript and a component-based approach, while Xamarin.Forms uses C# and XAML. React Native's code is more concise and follows a declarative style, while Xamarin.Forms uses a more traditional object-oriented approach.

ionic-framework

50,896

A powerful cross-platform UI toolkit for building native-quality iOS, Android, and Progressive Web Apps with HTML, CSS, and JavaScript.

Pros of Ionic Framework

Web-based development using familiar technologies (HTML, CSS, JavaScript)
Larger ecosystem and community support
Easier to find developers with relevant skills

Cons of Ionic Framework

Performance may be slower than native apps
Limited access to native device features
Dependency on third-party plugins for some functionality

Code Comparison

Xamarin.Forms (XAML):

<StackLayout>
    <Label Text="Welcome to Xamarin.Forms!" />
    <Button Text="Click Me" Clicked="OnButtonClicked" />
</StackLayout>

Ionic Framework (HTML):

<ion-content>
    <h1>Welcome to Ionic!</h1>
    <ion-button (click)="onButtonClicked()">Click Me</ion-button>
</ion-content>

Both frameworks aim to simplify cross-platform mobile development, but they take different approaches. Xamarin.Forms uses C# and XAML to create native apps, while Ionic Framework leverages web technologies to build hybrid apps. Xamarin.Forms generally offers better performance and deeper integration with native APIs, but requires more platform-specific knowledge. Ionic Framework provides a more familiar development experience for web developers and faster development cycles, but may sacrifice some performance and native feel.

NativeScript

24,061

Pros of NativeScript

Uses JavaScript or TypeScript, which are more widely known than C#
Allows direct access to native APIs without wrappers
Smaller app size and potentially better performance

Cons of NativeScript

Smaller community and ecosystem compared to Xamarin.Forms
Less mature tooling and IDE integration
Steeper learning curve for developers new to mobile development

Code Comparison

NativeScript (JavaScript):

import { Application } from "@nativescript/core";

Application.run({ moduleName: "app-root" });

exports.onNavigatingTo = function(args) {
    const page = args.object;
    page.bindingContext = { message: "Hello, NativeScript!" };
}

Xamarin.Forms (C#):

using Xamarin.Forms;

public class App : Application
{
    public App()
    {
        MainPage = new ContentPage
        {
            Content = new Label { Text = "Hello, Xamarin.Forms!" }
        };
    }
}

Both frameworks allow for cross-platform mobile development, but NativeScript focuses on JavaScript/TypeScript and direct native API access, while Xamarin.Forms uses C# and provides a more abstracted approach to UI development. NativeScript may offer better performance and smaller app sizes, while Xamarin.Forms benefits from a larger community and more mature tooling.

react-native-windows

16,237

A framework for building native Windows apps with React.

Pros of React Native Windows

Leverages JavaScript and React, allowing web developers to easily transition to Windows app development
Supports hot reloading, enabling faster development cycles
Provides access to native Windows APIs and components

Cons of React Native Windows

Limited to Windows platform, while Xamarin.Forms supports multiple platforms
Smaller community and ecosystem compared to Xamarin.Forms
May have performance limitations for complex, graphics-intensive applications

Code Comparison

React Native Windows:

import React from 'react';
import { View, Text } from 'react-native';

const App = () => (
  <View>
    <Text>Hello, Windows!</Text>
  </View>
);

Xamarin.Forms:

using Xamarin.Forms;

public class App : Application
{
    public App()
    {
        MainPage = new ContentPage
        {
            Content = new Label { Text = "Hello, Xamarin.Forms!" }
        };
    }
}

Both frameworks aim to simplify cross-platform development, but React Native Windows focuses specifically on Windows applications using React and JavaScript, while Xamarin.Forms provides a broader cross-platform solution using C# and .NET. The choice between them depends on the developer's preferred language, target platforms, and specific project requirements.

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

Xamarin.Forms

Support

Support for Xamarin.Forms ended on May 1, 2024 as per the Xamarin Support Policy:

Xamarin support ended on May 1, 2024 for all Xamarin SDKs including Xamarin.Forms.

Xamarin.Forms was succeeded by .NET MAUI in May 2022 as part of .NET 6, and is currently supported as described on the .NET MAUI Support Policy. Follow the official upgrade guidance to bring your Xamarin applications to the latest version of .NET.

To all our developers and contributors, thank you so much for being a part of our Xamarin community. We'll see you all over in .NET MAUI!

About Xamarin.Forms

Xamarin.Forms provides a way to quickly build native apps for iOS, Android, Windows and macOS, completely in C#.

Read more about the platform at https://www.xamarin.com/forms.

Packages

Platform/Feature	Package name	Stable	Prerelease	Nightly Feed Azure (main branch)
Core	`Xamarin.Forms`
AppLinks	`Xamarin.Forms.AppLinks`
Maps	`Xamarin.Forms.Maps`
Maps.GTK	`Xamarin.Forms.Maps.GTK`
Maps.WPF	`Xamarin.Forms.Maps.WPF`
Pages	`Xamarin.Forms.Pages`
Pages.Azure	`Xamarin.Forms.Pages.Azure`
Platform.GTK	`Xamarin.Forms.Platform.GTK`
Platform.WPF	`Xamarin.Forms.Platform.WPF`
Visual.Material	`Xamarin.Forms.Visual.Material`

If you want to use the latest dev build then you should read this blog post:

Add the nightly feed to your NuGet sources or add a NuGet.Config to your app (placing it in the same directory where your solution file is) with the following content:
```
<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <packageSources>
    <clear />
    <add key="xamarin-ci" value="https://aka.ms/xf-nightly/index.json" />
    <add key="NuGet.org" value="https://api.nuget.org/v3/index.json" />
  </packageSources>
</configuration>
```
NOTE: This NuGet.Config should be with your application unless you want nightly packages to potentially start being restored for other apps on the machine.
Change your application's dependencies to have a * to get the latest version.

Getting Started

For both methods underneath you will have to add this NuGet feed for the build to succeed. See this documentation page to find out how.

Windows

Install Visual Studio 2019+

VS 2019+ is required for developing Xamarin.Forms. If you do not already have it installed, you can download it here. VS 2019+ Community is completely free. If you are installing VS 2019+ for the first time, select the "Custom" installation type and select the following from the features list to install:

.NET desktop development
- Individual Components > .NET > .NET Framework 4.6.1 SDK, .NET Framework 4.6.1 targeting pack, .NET Framework 4.7.2 SDK, .NET Framework 4.7.2 targeting pack.
Universal Windows Platform Development
- Individual Components > SDKs, libraries, and frameworks > Windows 10 SDK (10.0.19041.0), Windows 10 SDK (10.0.18362.0), Windows 10 SDK (10.0.16299.0).
- Download and install 14393 from https://go.microsoft.com/fwlink/p/?LinkId=838916
Mobile Development with .NET
- Individual Components > Development Activities > Xamarin Remoted Simulator
- If you're not using Hyper-V Individual Components > Emulators > Hyper-V Intel Hardware Accelerated Execution Manager (HAXM)
Most current SDK version of .NET Core
- Or install the most current .NET Core SDK from here https://dotnet.microsoft.com/download

The Android 10.0 API 29 SDK and Android 9.0 API 28 SDK are required for developing Xamarin.Forms. They can be installed by using the Xamarin Android SDK Manager.

We also recommend installing Xamarin Android Device Manager. This will use the HAXM tools installed above and allow you to configure Android Virtual Devices (AVDs) that emulate Android devices. If you already have VS 2019+ installed, you can verify that these features are installed by modifying the VS 2019+ installation via the Visual Studio Installer.

Provisioning script

If you are getting errors about missing SDKs, you can run our provisioning script. Note that it can take some time to run the whole script. To better understand how the script works, feel free to check out our build.cake file.

On CMD
```
build.cmd -Target provision
```
On Powershell
```
./build.ps1 -Target provision
```
NOTE: If you encounter an error saying build.ps1 is not digitally signed, open Powershell as an administrator and resolve by running Set-ExecutionPolicy RemoteSigned first.

On CMD/Powershell/sh (New! More info here)

dotnet tool install Cake.Tool -g
dotnet cake --target=provision

Mac

Install Visual Studio for Mac 2019

If you do not already have it installed, instructions to download and setup can be found here.

Because of current Multi-Targeting limitations with Visual Studio for Mac you will need to manually build/restore some projects before you are able to work on the Xamarin Forms solution.

Here are a few different options we've put together to help make this process easier

Branches 3.5+ come with a Cake script target that you can use to build and open VSMac
```
./build.sh --target vsmac
```
OR as mentioned above in the Windows section about provisioning, you can also use the new Cake.Tool
```
dotnet tool install Cake.Tool -g
dotnet cake --target=provision
```
When working on an earlier branch that does not have the cake scripts, you can use the following build.sh script
If you don't want to run any scripts:
- Open Xamarin.Forms.sln
- Wait for VSMAC to finish restoring all projects
- from the command line run:
  - msbuild Xamarin.Forms.Build.Tasks/Xamarin.Forms.Build.Tasks.csproj
- Now you should be able to run and deploy everything. The only reason you would need to do this process again is if you clean the solution folder or delete the bin/obj folders that are part of the Xamarin.Forms.Build.Tasks.csproj

Solution Configuration

Upon opening the Xamarin.Forms solution, you will find that there are a number of errors and warnings under the Error List pane; you can resolve this by changing the filter of Build + IntelliSense to Build Only. At this point, you should be able to successfully build the solution.

By default, the Xamarin.Forms.Controls project does not have a configuration for various API keys to access certain features on each platform (e.g. maps). When building the solution for the first time, a controlgallery.config file will be generated inside that project, which looks like this:

UWPMapsAuthKey:

If you aren't working with maps, you can ignore this. If you want to work with maps, you will have to obtain your own API keys for each of these services, inserted directly after the identifier (e.g. UWPMapsAuthKey:abcdefghijklmnopqrstuvwxyz). You can find out how to obtain each of these as follows:

UWPMapsAuthKey at https://microsoft.com/maps/create-a-bing-maps-key.aspx

Due to the way that Android works, the maps API key cannot be injected at runtime. As a result, you will have to add this key to the MapsKey.cs file under Xamarin.Forms.ControlGallery.Android/Properties:

[assembly: Android.App.MetaData("com.google.android.maps.v2.API_KEY", Value = "INSERT_KEY_HERE")]

You can find out how to obtain a Google Maps API key here.

Build from the Command line

Make sure you have nuget.exe 4.0 or above and the latest .NET Core SDK. On macOS you should specify the platform in the msbuild command (/p:Platform=iPhoneSimulator)

msbuild /restore Xamarin.Forms.sln

UI Tests

Run Android UI Tests

Depending on your environment setup, you might need to configure a few things before being able to debug / run UI tests, especially on Windows.

If you receive an error about ANDROID_HOME, please make sure to set your environment variable to the Android SDK directory (e.g. C:\Program Files (x86)\Android\android-sdk).
If you receive an error about JAVA_HOME, please install the latest Java JDK and set your environment variable to the JDK directory (e.g. C:\Program Files\Java\jdk-13).
If you receive an error about a missing ApkFile, please generate an APK file for Xamarin.Forms.ControlGallery.Android. The easiest way to do this is to right click the project and select "Deploy". Note that if you rebuild the solution, you might lose the APK and will need to generate it again.

After these steps are taken care of, you should be good to go. You can see all UI tests in Test Explorer, search them for your own convenience, and quickly run individual tests.

Run UWP UI Tests

To run the UWP UI Tests:

Install and run the Windows Application Driver.
Launch the Xamarin.Forms.ControlGallery.WindowsUniversal project to install the ControlGallery application onto your system.

You should now be able to run any of the UWP UI Tests.

Coding Style

We follow the style used by the .NET Foundation, with a few exceptions:

We do not use the private keyword as it is the default accessibility level in C#.
We use hard tabs over spaces. You can change this setting in Visual Studio for Windows via Tools > Options and navigating to Text Editor > C# and selecting the "Keep tabs" radio option. In Visual Studio for Mac it's set via preferences in Source Code > Code Formatting > C# source code and disabling the checkbox for Convert tabs to spaces.
Lines should be limited to a max of 120 characters (or as close as possible within reason). This may be set in Visual Studio for Mac via preferences in Source Code > Code Formatting > C# source code and changing the Desired file width to 120.

Contributing

How to Contribute

Reporting Bugs

We use GitHub Issues to track issues. If at all possible, please submit a reproduction of your bug along with your bug report.

Stats

Top Related Projects

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot