diff --git a/Xamarin.Forms.ControlGallery.Android/Properties/AndroidManifest.xml b/Xamarin.Forms.ControlGallery.Android/Properties/AndroidManifest.xml
index 9bbcafdfce4..6b7581d5369 100644
--- a/Xamarin.Forms.ControlGallery.Android/Properties/AndroidManifest.xml
+++ b/Xamarin.Forms.ControlGallery.Android/Properties/AndroidManifest.xml
@@ -16,7 +16,7 @@
 	<uses-permission android:name="android.permission.READ_LOGS" />
 	<uses-permission android:name="android.permission.BIND_NOTIFICATION_LISTENER_SERVICE" />
 	<uses-feature android:glEsVersion="0x00020000" android:required="true" />
-	<application android:label="AndroidControlGallery">
+	<application android:label="AndroidControlGallery" android:supportsRtl="true">
 		<meta-data android:name="com.google.android.gms.version" android:value="@integer/google_play_services_version" />
 	</application>
 </manifest>
\ No newline at end of file
diff --git a/Xamarin.Forms.ControlGallery.WP8/App.xaml.cs b/Xamarin.Forms.ControlGallery.WP8/App.xaml.cs
index 5b83678624f..ea0eed04bb1 100644
--- a/Xamarin.Forms.ControlGallery.WP8/App.xaml.cs
+++ b/Xamarin.Forms.ControlGallery.WP8/App.xaml.cs
@@ -209,7 +209,7 @@ void InitializeLanguage()
 				//
 				// If a compiler error is hit then ResourceFlowDirection is missing from
 				// the resource file.
-				FlowDirection flow = (FlowDirection)Enum.Parse(typeof(FlowDirection), AppResources.ResourceFlowDirection);
+				System.Windows.FlowDirection flow = (System.Windows.FlowDirection)Enum.Parse(typeof(System.Windows.FlowDirection), AppResources.ResourceFlowDirection);
 				RootFrame.FlowDirection = flow;
 			}
 			catch
diff --git a/Xamarin.Forms.ControlGallery.WindowsUniversal/Package.appxmanifest b/Xamarin.Forms.ControlGallery.WindowsUniversal/Package.appxmanifest
index 6430b2f6c95..8685c121880 100644
--- a/Xamarin.Forms.ControlGallery.WindowsUniversal/Package.appxmanifest
+++ b/Xamarin.Forms.ControlGallery.WindowsUniversal/Package.appxmanifest
@@ -12,6 +12,8 @@
   </Dependencies>
   <Resources>
     <Resource Language="x-generate" />
+     <Resource Language="en" /> 
+     <Resource Language="ar" />
   </Resources>
   <Applications>
     <Application Id="App" Executable="$targetnametoken$.exe" EntryPoint="Xamarin.Forms.ControlGallery.WindowsUniversal.App">
diff --git a/Xamarin.Forms.ControlGallery.iOS/Info.plist b/Xamarin.Forms.ControlGallery.iOS/Info.plist
index 2b8924ceedc..7734872cb3a 100644
--- a/Xamarin.Forms.ControlGallery.iOS/Info.plist
+++ b/Xamarin.Forms.ControlGallery.iOS/Info.plist
@@ -96,6 +96,13 @@
 			<string>{320, 480}</string>
 		</dict>
 	</array>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>en</string>
+	<key>CFBundleLocalizations</key>
+	<array>
+		<string>en</string>
+		<string>ar</string>
+	</array>
 	<key>NSAppTransportSecurity</key>
 	<dict>
 		<key>NSAllowsArbitraryLoads </key>
diff --git a/Xamarin.Forms.ControlGallery.iOS/Xamarin.Forms.ControlGallery.iOS.csproj b/Xamarin.Forms.ControlGallery.iOS/Xamarin.Forms.ControlGallery.iOS.csproj
index b43776fc58a..f8c97b61dff 100644
--- a/Xamarin.Forms.ControlGallery.iOS/Xamarin.Forms.ControlGallery.iOS.csproj
+++ b/Xamarin.Forms.ControlGallery.iOS/Xamarin.Forms.ControlGallery.iOS.csproj
@@ -78,7 +78,7 @@
     <MtouchUseLlvm>False</MtouchUseLlvm>
     <MtouchUseThumb>False</MtouchUseThumb>
     <MtouchOptimizePNGs>True</MtouchOptimizePNGs>
-    <MtouchI18n />
+    <MtouchI18n>mideast</MtouchI18n>
     <BuildIpa>True</BuildIpa>
     <IpaMetadata />
     <IpaPackageName />
@@ -132,6 +132,9 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'AppStore|iPhoneSimulator'">
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
   </PropertyGroup>
+  <PropertyGroup Condition=" '$(RunConfiguration)' == 'Default' ">
+    <AppExtensionDebugBundleId />
+  </PropertyGroup>
   <ItemGroup>
     <Compile Include="BrokenImageSourceHandler.cs" />
     <Compile Include="BrokenNativeControl.cs" />
diff --git a/Xamarin.Forms.Controls/ControlGalleryPages/FlowDirectionGallery.cs b/Xamarin.Forms.Controls/ControlGalleryPages/FlowDirectionGallery.cs
new file mode 100644
index 00000000000..eb2e0f79172
--- /dev/null
+++ b/Xamarin.Forms.Controls/ControlGalleryPages/FlowDirectionGallery.cs
@@ -0,0 +1,429 @@
+using System;
+using System.Linq;
+
+namespace Xamarin.Forms.Controls
+{
+
+	public class FlowDirectionGalleryLandingPage : ContentPage
+	{
+		FlowDirection DeviceDirection => Device.FlowDirection;
+
+		public FlowDirectionGalleryLandingPage()
+		{
+
+			var np = new Button { Text = "Try NavigationPage", Command = new Command(() => { PushNavigationPage(DeviceDirection); }) };
+			var mdp = new Button { Text = "Try MasterDetailPage", Command = new Command(() => { PushMasterDetailPage(DeviceDirection); }) };
+			var crp = new Button { Text = "Try CarouselPage", Command = new Command(() => { PushCarouselPage(DeviceDirection); }) };
+			var tp = new Button { Text = "Try TabbedPage", Command = new Command(() => { PushTabbedPage(DeviceDirection); }) };
+			var cp = new Button { Text = "Try ContentPage", Command = new Command(() => { PushContentPage(DeviceDirection); }) };
+
+			Content = new StackLayout
+			{
+				Children = {
+					new Label { Text = "Click a button below to swap the MainPage of the app." },
+					np,
+					mdp,
+					crp,
+					tp,
+					cp
+				}
+			};
+		}
+
+		public static void PushNavigationPage(FlowDirection direction)
+		{
+			((App)Application.Current).SetMainPage(new FlowDirectionGalleryNP(direction));
+		}
+
+		public static void PushMasterDetailPage(FlowDirection direction)
+		{
+			((App)Application.Current).SetMainPage(new FlowDirectionGalleryMDP(direction));
+		}
+
+		public static void PushCarouselPage(FlowDirection direction)
+		{
+			((App)Application.Current).SetMainPage(new FlowDirectionGalleryCarP(direction));
+		}
+
+		public static void PushTabbedPage(FlowDirection direction)
+		{
+			((App)Application.Current).SetMainPage(new FlowDirectionGalleryTP(direction));
+		}
+
+		public static void PushContentPage(FlowDirection direction)
+		{
+			((App)Application.Current).SetMainPage(new FlowDirectionGalleryCP(direction)
+			{
+				FlowDirection = direction
+			});
+		}
+	}
+
+	public class FlowDirectionGalleryNP : NavigationPage
+	{
+		public FlowDirectionGalleryNP(FlowDirection direction)
+		{
+			FlowDirection = direction;
+			Navigation.PushAsync(new FlowDirectionGalleryCP(direction));
+			Navigation.PushAsync(new FlowDirectionGalleryCP(direction));
+		}
+	}
+
+	public class FlowDirectionGalleryMDP : MasterDetailPage
+	{
+		public FlowDirectionGalleryMDP(FlowDirection direction)
+		{
+			FlowDirection = direction;
+			Master = new FlowDirectionGalleryCP(direction) { Title = "Master", BackgroundColor = Color.Red };
+			Detail = new FlowDirectionGalleryCP(direction) { Title = "Detail" };
+			IsPresented = true;
+		}
+	}
+
+	public class FlowDirectionGalleryCarP : CarouselPage
+	{
+		public FlowDirectionGalleryCarP(FlowDirection direction)
+		{
+			FlowDirection = direction;
+			Children.Add(new FlowDirectionGalleryCP(direction) { Title = "1" });
+			Children.Add(new FlowDirectionGalleryCP(direction) { Title = "2" });
+			Children.Add(new FlowDirectionGalleryCP(direction) { Title = "3" });
+		}
+	}
+
+	public class FlowDirectionGalleryTP : TabbedPage
+	{
+		public FlowDirectionGalleryTP(FlowDirection direction)
+		{
+			FlowDirection = direction;
+			Children.Add(new FlowDirectionGalleryCP(direction) { Title = "1", BackgroundColor = Color.Red });
+			Children.Add(new FlowDirectionGalleryCP(direction) { Title = "2", BackgroundColor = Color.Orange });
+			Children.Add(new FlowDirectionGalleryCP(direction) { Title = "3", BackgroundColor = Color.Yellow });
+		}
+	}
+
+	public class FlowDirectionGalleryCP : ContentPage
+	{
+		FlowDirection DeviceDirection => Device.FlowDirection;
+
+		Page ParentPage => (Parent as Page) ?? this;
+
+		public FlowDirectionGalleryCP(FlowDirection direction)
+		{
+			var item = new ToolbarItem
+			{
+				Icon = "coffee.png",
+				Text = "Item 1",
+			};
+
+			var item2 = new ToolbarItem
+			{
+				Icon = "bank.png",
+				Text = "Item 2",
+			};
+
+			ToolbarItems.Add(item);
+			ToolbarItems.Add(item2);
+
+			Title = "Flow Direction Gallery";
+			NavigationPage.SetHasBackButton(this, true);
+			NavigationPage.SetBackButtonTitle(this, "Back");
+			SetContent(direction);
+		}
+
+		void SetContent(FlowDirection direction)
+		{
+			var hOptions = LayoutOptions.Start;
+
+			var imageCell = new DataTemplate(typeof(ImageCell));
+			imageCell.SetBinding(ImageCell.ImageSourceProperty, ".");
+			imageCell.SetBinding(ImageCell.TextProperty, ".");
+
+			var textCell = new DataTemplate(typeof(TextCell));
+			textCell.SetBinding(TextCell.DetailProperty, ".");
+
+			var entryCell = new DataTemplate(typeof(EntryCell));
+			entryCell.SetBinding(EntryCell.TextProperty, ".");
+
+			var switchCell = new DataTemplate(typeof(SwitchCell));
+			switchCell.SetBinding(SwitchCell.OnProperty, ".");
+			switchCell.SetValue(SwitchCell.TextProperty, "Switch Cell!");
+
+			var vc = new ViewCell
+			{
+				View = new StackLayout
+				{
+					Children = { new Label { HorizontalOptions = hOptions, Text = "View Cell! I have context actions." } }
+				}
+			};
+
+			var a1 = new MenuItem { Text = "First" };
+			vc.ContextActions.Add(a1);
+			var a2 = new MenuItem { Text = "Second" };
+			vc.ContextActions.Add(a2);
+
+			var viewCell = new DataTemplate(() => vc);
+
+			var relayout = new Switch
+			{
+				IsToggled = true,
+				HorizontalOptions = LayoutOptions.End,
+				VerticalOptions = LayoutOptions.Center
+			};
+
+			var flipButton = new Button
+			{
+				Text = direction == FlowDirection.RightToLeft ? "Switch to Left To Right" : "Switch to Right To Left",
+				HorizontalOptions = LayoutOptions.StartAndExpand,
+				VerticalOptions = LayoutOptions.Center
+			};
+
+			flipButton.Clicked += (s, e) =>
+			{
+				FlowDirection newDirection;
+				if (direction == FlowDirection.LeftToRight || direction == FlowDirection.MatchParent)
+					newDirection = FlowDirection.RightToLeft;
+				else
+					newDirection = FlowDirection.LeftToRight;
+
+				if (relayout.IsToggled)
+				{
+					ParentPage.FlowDirection = newDirection;
+
+					direction = newDirection;
+
+					flipButton.Text = direction == FlowDirection.RightToLeft ? "Switch to Left To Right" : "Switch to Right To Left";
+
+					return;
+				}
+
+				if (ParentPage == this)
+				{
+					FlowDirectionGalleryLandingPage.PushContentPage(newDirection);
+					return;
+				}
+				string parentType = ParentPage.GetType().ToString();
+				switch (parentType)
+				{
+					case "Xamarin.Forms.Controls.FlowDirectionGalleryMDP":
+						FlowDirectionGalleryLandingPage.PushMasterDetailPage(newDirection);
+						break;
+					case "Xamarin.Forms.Controls.FlowDirectionGalleryCarP":
+						FlowDirectionGalleryLandingPage.PushCarouselPage(newDirection);
+						break;
+					case "Xamarin.Forms.Controls.FlowDirectionGalleryNP":
+						FlowDirectionGalleryLandingPage.PushNavigationPage(newDirection);
+						break;
+					case "Xamarin.Forms.Controls.FlowDirectionGalleryTP":
+						FlowDirectionGalleryLandingPage.PushTabbedPage(newDirection);
+						break;
+				}
+			};
+
+			var horStack = new StackLayout
+			{
+				Orientation = StackOrientation.Horizontal,
+				Children = { flipButton, new Label { Text = "Relayout", HorizontalOptions = LayoutOptions.End, VerticalOptions = LayoutOptions.Center }, relayout }
+			};
+
+			var grid = new Grid
+			{
+				ColumnDefinitions = {
+					new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) },
+					new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) },
+				},
+				RowDefinitions = {
+					new RowDefinition { Height = new GridLength(100, GridUnitType.Absolute) },
+					new RowDefinition { Height = new GridLength(100, GridUnitType.Absolute) },
+					new RowDefinition { Height = new GridLength(100, GridUnitType.Absolute) },
+					new RowDefinition { Height = new GridLength(100, GridUnitType.Absolute) },
+					new RowDefinition { Height = new GridLength(100, GridUnitType.Absolute) },
+					new RowDefinition { Height = new GridLength(100, GridUnitType.Absolute) },
+					new RowDefinition { Height = new GridLength(100, GridUnitType.Absolute) },
+				}
+			};
+
+			int col = 0;
+			int row = 0;
+
+			var ai = AddView<ActivityIndicator>(grid, ref col, ref row);
+			ai.IsRunning = true;
+
+			var box = AddView<BoxView>(grid, ref col, ref row);
+			box.WidthRequest = box.HeightRequest = 20;
+			box.BackgroundColor = Color.Purple;
+
+			var btn = AddView<Button>(grid, ref col, ref row);
+			btn.Text = "Some text";
+
+			var date = AddView<DatePicker>(grid, ref col, ref row, 2);
+
+			var edit = AddView<Editor>(grid, ref col, ref row);
+			edit.WidthRequest = 100;
+			edit.HeightRequest = 100;
+			edit.Text = "Some longer text for wrapping";
+
+			var entry = AddView<Entry>(grid, ref col, ref row);
+			entry.WidthRequest = 100;
+			entry.Text = "Some text";
+
+			var image = AddView<Image>(grid, ref col, ref row);
+			image.Source = "oasis.jpg";
+
+			var lbl1 = AddView<Label>(grid, ref col, ref row);
+			lbl1.WidthRequest = 100;
+			lbl1.HorizontalTextAlignment = TextAlignment.Start;
+			lbl1.Text = "Start text";
+
+			var lblLong = AddView<Label>(grid, ref col, ref row);
+			lblLong.WidthRequest = 100;
+			lblLong.HorizontalTextAlignment = TextAlignment.Start;
+			lblLong.Text = "Start text that should wrap and wrap and wrap";
+
+			var lbl2 = AddView<Label>(grid, ref col, ref row);
+			lbl2.WidthRequest = 100;
+			lbl2.HorizontalTextAlignment = TextAlignment.End;
+			lbl2.Text = "End text";
+
+			var lbl3 = AddView<Label>(grid, ref col, ref row);
+			lbl3.WidthRequest = 100;
+			lbl3.HorizontalTextAlignment = TextAlignment.Center;
+			lbl3.Text = "Center text";
+
+			//var ogv = AddView<OpenGLView>(grid, ref col, ref row, hOptions, vOptions, margin);
+
+			var pkr = AddView<Picker>(grid, ref col, ref row);
+			pkr.ItemsSource = Enumerable.Range(0, 10).ToList();
+
+			var sld = AddView<Slider>(grid, ref col, ref row);
+			sld.WidthRequest = 100;
+			sld.Maximum = 10;
+			Device.StartTimer(TimeSpan.FromSeconds(1), () =>
+			{
+				sld.Value += 1;
+				if (sld.Value == 10d)
+					sld.Value = 0;
+				return true;
+			});
+
+			var stp = AddView<Stepper>(grid, ref col, ref row);
+
+			var swt = AddView<Switch>(grid, ref col, ref row);
+
+			var time = AddView<TimePicker>(grid, ref col, ref row, 2);
+
+			var prog = AddView<ProgressBar>(grid, ref col, ref row, 2);
+			prog.WidthRequest = 200;
+			prog.BackgroundColor = Color.DarkGray;
+			Device.StartTimer(TimeSpan.FromSeconds(1), () =>
+			{
+				prog.Progress += .1;
+				if (prog.Progress == 1d)
+					prog.Progress = 0;
+				return true;
+			});
+
+			var srch = AddView<SearchBar>(grid, ref col, ref row, 2);
+			srch.WidthRequest = 200;
+			srch.Text = "Some text";
+
+			TableView tbl = new TableView
+			{
+				Intent = TableIntent.Menu,
+				Root = new TableRoot
+					{
+						new TableSection("TableView")
+						{
+							new TextCell
+							{
+								Text = "A",
+							},
+
+							new TextCell
+							{
+								Text = "B",
+							},
+
+							new TextCell
+							{
+								Text = "C",
+							},
+
+							new TextCell
+							{
+								Text = "D",
+							},
+						}
+					}
+			};
+
+			var stack = new StackLayout
+			{
+				Children = {        new Button { Text = "Go back to Gallery home", Command = new Command(()=> { ((App)Application.Current).SetMainPage(((App)Application.Current).CreateDefaultMainPage()); }) },
+									new Label { Text = $"Device Direction: {DeviceDirection}" },
+									horStack,
+									grid,
+									new Label { Text = "TableView", FontSize = 10, TextColor = Color.DarkGray },
+									tbl,
+									new Label { Text = "ListView w/ TextCell", FontSize = 10, TextColor = Color.DarkGray },
+									new ListView { HorizontalOptions = hOptions, ItemsSource = Enumerable.Range(0, 3).Select(c => "Text Cell!"), ItemTemplate = textCell },
+									new Label { Text = "ListView w/ SwitchCell", FontSize = 10, TextColor = Color.DarkGray },
+									new ListView { HorizontalOptions = hOptions, ItemsSource = Enumerable.Range(0, 3).Select(c => true), ItemTemplate = switchCell },
+									new Label { Text = "ListView w/ EntryCell", FontSize = 10, TextColor = Color.DarkGray },
+									new ListView { HorizontalOptions = hOptions, ItemsSource = Enumerable.Range(0, 3).Select(c => "Entry Cell!"), ItemTemplate = entryCell },
+									new Label { Text = "ListView w/ ImageCell", FontSize = 10, TextColor = Color.DarkGray },
+									new ListView { HorizontalOptions = hOptions, ItemsSource = Enumerable.Range(0, 3).Select(c => "coffee.png"), ItemTemplate = imageCell },
+									new Label { Text = "ListView w/ ViewCell", FontSize = 10, TextColor = Color.DarkGray },
+									new ListView { HorizontalOptions = hOptions, ItemsSource = Enumerable.Range(0, 3), ItemTemplate = viewCell },
+								 },
+
+				HorizontalOptions = hOptions
+			};
+
+			Content = new ScrollView
+			{
+				Content = stack
+			};
+		}
+
+		T AddView<T>(Grid grid, ref int col, ref int row, int colSpan = 1) where T : View
+		{
+			var hOptions = LayoutOptions.Start;
+			var vOptions = LayoutOptions.End;
+			var margin = new Thickness(0, 10);
+			var bgColor = Color.LightGray;
+
+			T view = (T)Activator.CreateInstance(typeof(T));
+
+			view.VerticalOptions = vOptions;
+			view.HorizontalOptions = hOptions;
+			view.Margin = margin;
+			view.BackgroundColor = bgColor;
+
+			var label = new Label { Text = $"({col},{row}) {typeof(T).ToString()}", FontSize = 10, TextColor = Color.DarkGray };
+
+			if (colSpan > 1 && col > 0)
+				NextCell(ref col, ref row, colSpan);
+
+			grid.Children.Add(label, col, col + colSpan, row, row + 1);
+			grid.Children.Add(view, col, col + colSpan, row, row + 1);
+
+			NextCell(ref col, ref row, colSpan);
+
+			return (T)view;
+		}
+
+		void NextCell(ref int col, ref int row, int colspan)
+		{
+			if (col == 0 && colspan == 1)
+			{
+				col = 1;
+			}
+			else
+			{
+				col = 0;
+				row++;
+			}
+		}
+	}
+}
\ No newline at end of file
diff --git a/Xamarin.Forms.Controls/CoreGallery.cs b/Xamarin.Forms.Controls/CoreGallery.cs
index 26e9a5905d2..14760136165 100644
--- a/Xamarin.Forms.Controls/CoreGallery.cs
+++ b/Xamarin.Forms.Controls/CoreGallery.cs
@@ -245,6 +245,7 @@ public override string ToString()
 		}
 
 		List<GalleryPageFactory> _pages = new List<GalleryPageFactory> {
+				new GalleryPageFactory(() => new FlowDirectionGalleryLandingPage(), "FlowDirection"),
 				new GalleryPageFactory(() => new AutomationPropertiesGallery(), "Accessibility"),
 				new GalleryPageFactory(() => new PlatformSpecificsGallery(), "Platform Specifics"),
 				new GalleryPageFactory(() => new NativeBindingGalleryPage(), "Native Binding Controls Gallery"),
diff --git a/Xamarin.Forms.Controls/Xamarin.Forms.Controls.csproj b/Xamarin.Forms.Controls/Xamarin.Forms.Controls.csproj
index 4fa243cdf1d..c88401e103e 100644
--- a/Xamarin.Forms.Controls/Xamarin.Forms.Controls.csproj
+++ b/Xamarin.Forms.Controls/Xamarin.Forms.Controls.csproj
@@ -75,6 +75,7 @@
     <Compile Include="Bugzilla44596SplashPage.cs" />
     <Compile Include="ControlGalleryPages\AutomationPropertiesGallery.cs" />
     <Compile Include="ControlGalleryPages\CellForceUpdateSizeGalleryPage.cs" />
+    <Compile Include="ControlGalleryPages\FlowDirectionGallery.cs" />
     <Compile Include="ControlGalleryPages\LayoutAddPerformance.xaml.cs">
       <DependentUpon>LayoutAddPerformance.xaml</DependentUpon>
     </Compile>
diff --git a/Xamarin.Forms.Core.UnitTests/EffectiveFlowDirectionExtensions.cs b/Xamarin.Forms.Core.UnitTests/EffectiveFlowDirectionExtensions.cs
new file mode 100644
index 00000000000..39875a6db39
--- /dev/null
+++ b/Xamarin.Forms.Core.UnitTests/EffectiveFlowDirectionExtensions.cs
@@ -0,0 +1,58 @@
+using NUnit.Framework;
+using System.Linq;
+
+namespace Xamarin.Forms.Core.UnitTests
+{
+	[TestFixture]
+	public class EffectiveFlowDirectionExtensions : BaseTestFixture
+	{
+
+		[Test]
+		public void LeftToRightImplicit()
+		{
+			var target = FlowDirection.LeftToRight.ToEffectiveFlowDirection();
+
+			Assert.IsTrue(target.IsLeftToRight());
+			Assert.IsTrue(target.IsImplicit());
+
+			Assert.IsFalse(target.IsRightToLeft());
+			Assert.IsFalse(target.IsExplicit());
+		}
+
+		[Test]
+		public void LeftToRightExplicit()
+		{
+			var target = FlowDirection.LeftToRight.ToEffectiveFlowDirection(isExplicit: true);
+
+			Assert.IsTrue(target.IsLeftToRight());
+			Assert.IsTrue(target.IsExplicit());
+
+			Assert.IsFalse(target.IsRightToLeft());
+			Assert.IsFalse(target.IsImplicit());
+		}
+
+		[Test]
+		public void RightToLeftImplicit()
+		{
+			var target = FlowDirection.RightToLeft.ToEffectiveFlowDirection();
+
+			Assert.IsTrue(target.IsRightToLeft());
+			Assert.IsTrue(target.IsImplicit());
+
+			Assert.IsFalse(target.IsLeftToRight());
+			Assert.IsFalse(target.IsExplicit());
+		}
+
+		[Test]
+		public void RightToLeftExplicit()
+		{
+			var target = FlowDirection.RightToLeft.ToEffectiveFlowDirection(isExplicit: true);
+
+			Assert.IsTrue(target.IsRightToLeft());
+			Assert.IsTrue(target.IsExplicit());
+
+			Assert.IsFalse(target.IsLeftToRight());
+			Assert.IsFalse(target.IsImplicit());
+		}
+	}
+}
\ No newline at end of file
diff --git a/Xamarin.Forms.Core.UnitTests/FlowDirectionTests.cs b/Xamarin.Forms.Core.UnitTests/FlowDirectionTests.cs
new file mode 100644
index 00000000000..af531e161d6
--- /dev/null
+++ b/Xamarin.Forms.Core.UnitTests/FlowDirectionTests.cs
@@ -0,0 +1,630 @@
+using NUnit.Framework;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using Xamarin.Forms.Internals;
+
+namespace Xamarin.Forms.Core.UnitTests
+{
+	[TestFixture]
+	public class FlowDirectionTests : BaseTestFixture
+	{
+
+		[Test]
+		public void ListViewFlowDirectionIsInheritedByViewCells()
+		{
+			var lv = new ListView { FlowDirection = FlowDirection.RightToLeft, ItemTemplate = new DataTemplate(() => new ViewCell { View = new View() }) };
+
+			lv.ItemsSource = Enumerable.Range(0, 10);
+
+			ViewCell cell = lv.TemplatedItems[0] as ViewCell;
+			IViewController target = cell.View;
+			Assert.IsTrue(target.EffectiveFlowDirection.IsRightToLeft(), "ViewCell View is not RightToLeft");
+		}
+
+		[Test]
+		public void ListViewFlowDirectionIsInheritedByImageInViewCells()
+		{
+			var lv = new ListView { FlowDirection = FlowDirection.RightToLeft, ItemTemplate = new DataTemplate(() => new ViewCell { View = new Label() }) };
+
+			lv.ItemsSource = Enumerable.Range(0, 10);
+
+			ViewCell cell = lv.TemplatedItems[0] as ViewCell;
+			IViewController target = cell.View;
+			Assert.IsTrue(target.EffectiveFlowDirection.IsRightToLeft(), "ViewCell View is not RightToLeft");
+		}
+
+		[Test]
+		public void ScrollViewSetsFlowDirectionAndGrandchildMaintainsParentExplicitValue()
+		{
+			var layout = ImplicitLeftToRightScrollView();
+			var layout2 = ExplicitRightToLeftScrollView();
+			IViewController view = ImplicitLeftToRightView();
+
+			AddExplicitRTLToScrollView(layout, layout2);
+			AddImplicitToRTLScrollView(layout2, (View)view);
+
+			layout.FlowDirection = FlowDirection.LeftToRight;
+
+			var target = view.EffectiveFlowDirection;
+
+			Assert.IsTrue(target.IsImplicit(), "EffectiveFlowDirection should be Implicit");
+			Assert.IsTrue(!target.IsExplicit(), "EffectiveFlowDirection should be Implicit");
+			Assert.IsTrue(target.IsRightToLeft(), "EffectiveFlowDirection should be RightToLeft");
+			Assert.IsTrue(!target.IsLeftToRight(), "EffectiveFlowDirection should be RightToLeft");
+
+			Assert.AreEqual(FlowDirection.MatchParent, ((View)view).FlowDirection);
+			Assert.AreEqual(FlowDirection.RightToLeft, layout2.FlowDirection);
+		}
+
+		[Test]
+		public void GrandparentSetsFlowDirectionAndGrandchildMaintainsParentExplicitValue()
+		{
+			var layout = ImplicitLeftToRightLayout();
+			var layout2 = ExplicitLeftToRightLayout();
+			IViewController view = ImplicitLeftToRightView();
+
+			AddExplicitLTRToLayout(layout, layout2);
+			AddImplicitToLTR(layout2, (View)view);
+
+			layout.FlowDirection = FlowDirection.RightToLeft;
+
+			var target = view.EffectiveFlowDirection;
+
+			Assert.IsTrue(target.IsImplicit(), "EffectiveFlowDirection should be Implicit");
+			Assert.IsTrue(!target.IsExplicit(), "EffectiveFlowDirection should be Implicit");
+			Assert.IsTrue(!target.IsRightToLeft(), "EffectiveFlowDirection should be LeftToRight");
+			Assert.IsTrue(target.IsLeftToRight(), "EffectiveFlowDirection should be LeftToRight");
+
+			Assert.AreEqual(FlowDirection.MatchParent, ((View)view).FlowDirection);
+			Assert.AreEqual(FlowDirection.LeftToRight, layout2.FlowDirection);
+		}
+
+		[Test]
+		public void GrandparentSetsFlowDirectionAndImplicitDescendentsInheritValue()
+		{
+			var layout = ImplicitLeftToRightLayout();
+			var layout2 = ImplicitLeftToRightLayout();
+			IViewController view = ImplicitLeftToRightView();
+
+			AddImplicitToLTR(layout, layout2);
+
+			AddImplicitToLTR(layout2, (View)view);
+
+			layout.FlowDirection = FlowDirection.RightToLeft;
+
+			Assume.That(((IViewController)layout).EffectiveFlowDirection.IsExplicit());
+			Assume.That(((IViewController)layout).EffectiveFlowDirection.IsRightToLeft());
+
+			Assume.That(((IViewController)layout2).EffectiveFlowDirection.IsImplicit());
+			Assume.That(((IViewController)layout2).EffectiveFlowDirection.IsRightToLeft());
+
+			var target = view.EffectiveFlowDirection;
+
+			Assert.IsTrue(target.IsImplicit(), "EffectiveFlowDirection should be Implicit");
+			Assert.IsTrue(!target.IsExplicit(), "EffectiveFlowDirection should be Implicit");
+			Assert.IsTrue(target.IsRightToLeft(), "EffectiveFlowDirection should be RightToLeft");
+			Assert.IsTrue(!target.IsLeftToRight(), "EffectiveFlowDirection should be RightToLeft");
+
+			Assert.AreEqual(FlowDirection.MatchParent, ((View)view).FlowDirection);
+			Assert.AreEqual(FlowDirection.MatchParent, layout2.FlowDirection);
+		}
+
+		[Test]
+		public void GrandparentSetsOppositeFlowDirectionAndGrandchildInheritsParentExplicitValue()
+		{
+			var layout = ExplicitRightToLeftLayout();
+			var layout2 = ExplicitRightToLeftLayout();
+			IViewController view = ImplicitLeftToRightView();
+
+			AddExplicitRTLToLayout(layout, layout2);
+
+			AddImplicitToRTL(layout2, (View)view);
+
+			layout.FlowDirection = FlowDirection.LeftToRight;
+
+			Assume.That(((IViewController)layout).EffectiveFlowDirection.IsExplicit());
+			Assume.That(((IViewController)layout).EffectiveFlowDirection.IsLeftToRight());
+
+			Assume.That(((IViewController)layout2).EffectiveFlowDirection.IsExplicit());
+			Assume.That(((IViewController)layout2).EffectiveFlowDirection.IsRightToLeft());
+
+			Assume.That(view.EffectiveFlowDirection.IsImplicit());
+			Assume.That(view.EffectiveFlowDirection.IsRightToLeft());
+
+			var target = ((View)view).FlowDirection;
+
+			Assert.AreEqual(FlowDirection.MatchParent, target);
+		}
+
+		[Test]
+		public void NotifyFlowDirectionChangedDoesNotTriggerFlowDirectionPropertyChangedUnnecessarily()
+		{
+			var layout = ExplicitRightToLeftLayout();
+			var layout2 = ImplicitLeftToRightLayout();
+			IViewController view = new PropertyWatchingView();
+
+			AddImplicitToRTL(layout, layout2);
+
+			AddImplicitToRTL(layout2, (View)view);
+
+			layout2.FlowDirection = FlowDirection.RightToLeft;
+			Assume.That(((IViewController)layout2).EffectiveFlowDirection.IsExplicit(), "Explicit EffectiveFlowDirection not set on inner layout");
+			Assume.That(view.EffectiveFlowDirection.IsRightToLeft(), "Implicit FlowDirection not set on view");
+
+			layout.FlowDirection = FlowDirection.LeftToRight;
+			Assume.That(layout2.FlowDirection == FlowDirection.RightToLeft, "Explicit FlowDirection not respected on inner layout");
+			Assume.That(view.EffectiveFlowDirection.IsRightToLeft(), "Implicit FlowDirection not set on view");
+
+			var target = ((PropertyWatchingView)view).FlowDirectionPropertyChangedCount;
+
+			Assert.AreEqual(1, target);
+		}
+
+		[Test]
+		public void ReParentAndInheritNewParentValue()
+		{
+			var layout = ExplicitRightToLeftLayout();
+			IViewController view = ImplicitLeftToRightView();
+			var layout2 = ExplicitLeftToRightLayout();
+
+			AddImplicitToRTL(layout, (View)view);
+
+			((View)view).Parent = layout2;
+
+			Assume.That(((IViewController)layout2).EffectiveFlowDirection.IsExplicit());
+			Assume.That(((IViewController)layout2).EffectiveFlowDirection.IsLeftToRight());
+
+			var target = view.EffectiveFlowDirection;
+
+			Assert.IsTrue(target.IsImplicit(), "EffectiveFlowDirection should be Implicit");
+			Assert.IsTrue(!target.IsExplicit(), "EffectiveFlowDirection should be Implicit");
+			Assert.IsTrue(!target.IsRightToLeft(), "EffectiveFlowDirection should be LeftToRight");
+			Assert.IsTrue(target.IsLeftToRight(), "EffectiveFlowDirection should be LeftToRight");
+
+			Assert.AreEqual(FlowDirection.MatchParent, ((View)view).FlowDirection);
+		}
+
+		[Test]
+		public void ReParentParentAndInheritNewGrandParentValue()
+		{
+			var layout = ExplicitRightToLeftLayout();
+			var layout2 = ImplicitLeftToRightLayout();
+			IViewController view = ImplicitLeftToRightView();
+			var layout3 = ExplicitLeftToRightLayout();
+
+			AddImplicitToRTL(layout, layout2);
+			AddImplicitToRTL(layout2, (View)view);
+
+			layout2.Parent = layout3;
+
+			Assume.That(((IViewController)layout2).EffectiveFlowDirection.IsImplicit());
+			Assume.That(((IViewController)layout2).EffectiveFlowDirection.IsLeftToRight());
+
+			Assume.That(view.EffectiveFlowDirection.IsImplicit());
+			Assume.That(view.EffectiveFlowDirection.IsLeftToRight());
+
+			var target = ((View)view).FlowDirection;
+
+			Assert.AreEqual(FlowDirection.MatchParent, target);
+		}
+
+		[Test]
+		public void SetFlowDirectionToMatchParentAndInheritParentValue()
+		{
+			var layout = ImplicitLeftToRightLayout();
+			var layout2 = ExplicitRightToLeftLayout();
+			IViewController view = ExplicitLeftToRightView();
+
+			AddExplicitRTLToLayout(layout, layout2);
+
+			AddExplicitLTRToLayout(layout2, (View)view);
+
+			((View)view).FlowDirection = FlowDirection.MatchParent;
+
+			var target = view.EffectiveFlowDirection;
+
+			Assert.IsTrue(target.IsImplicit(), "EffectiveFlowDirection should be Implicit");
+			Assert.IsTrue(!target.IsExplicit(), "EffectiveFlowDirection should be Implicit");
+			Assert.IsTrue(target.IsRightToLeft(), "EffectiveFlowDirection should be RightToLeft");
+			Assert.IsTrue(!target.IsLeftToRight(), "EffectiveFlowDirection should be RightToLeft");
+		}
+
+		[Test]
+		public void SetGrandparentAndInheritExplicitParentValue()
+		{
+			var layout = ExplicitRightToLeftLayout();
+			var layout2 = ExplicitLeftToRightLayout();
+			IViewController view = ImplicitLeftToRightView();
+
+			AddExplicitLTRToLayout(layout, layout2);
+			AddImplicitToLTR(layout2, (View)view);
+
+			var target = view.EffectiveFlowDirection;
+
+			Assume.That(((IViewController)layout).EffectiveFlowDirection.IsExplicit());
+			Assume.That(((IViewController)layout).EffectiveFlowDirection.IsRightToLeft());
+
+			Assume.That(((IViewController)layout2).EffectiveFlowDirection.IsExplicit());
+			Assume.That(((IViewController)layout2).EffectiveFlowDirection.IsLeftToRight());
+
+			Assert.IsTrue(target.IsImplicit(), "EffectiveFlowDirection should be Implicit");
+			Assert.IsTrue(!target.IsExplicit(), "EffectiveFlowDirection should be Implicit");
+			Assert.IsTrue(!target.IsRightToLeft(), "EffectiveFlowDirection should be LeftToRight");
+			Assert.IsTrue(target.IsLeftToRight(), "EffectiveFlowDirection should be LeftToRight");
+		}
+
+		[Test]
+		public void SetGrandparentUsingAnonCtorAndMaintainExplicitParentValue()
+		{
+			var layout = new StackLayout
+			{
+				FlowDirection = FlowDirection.RightToLeft,
+				Children = {
+					new StackLayout {
+						FlowDirection = FlowDirection.LeftToRight,
+						Children = { ImplicitLeftToRightView() }
+					}
+				}
+			};
+
+			var layout2 = layout.Children[0] as StackLayout;
+			IViewController view = layout2.Children[0] as View;
+
+			var target = view.EffectiveFlowDirection;
+
+			Assume.That(((IViewController)layout).EffectiveFlowDirection.IsExplicit());
+			Assume.That(((IViewController)layout).EffectiveFlowDirection.IsRightToLeft());
+
+			Assume.That(((IViewController)layout2).EffectiveFlowDirection.IsExplicit());
+			Assume.That(((IViewController)layout2).EffectiveFlowDirection.IsLeftToRight());
+
+			Assert.IsTrue(target.IsImplicit(), "EffectiveFlowDirection should be Implicit");
+			Assert.IsTrue(!target.IsExplicit(), "EffectiveFlowDirection should be Implicit");
+			Assert.IsTrue(!target.IsRightToLeft(), "EffectiveFlowDirection should be LeftToRight");
+			Assert.IsTrue(target.IsLeftToRight(), "EffectiveFlowDirection should be LeftToRight");
+		}
+
+		[Test]
+		public void SetGrandparentUsingCtorAndMaintainExplicitParentValue()
+		{
+			IViewController view = ImplicitLeftToRightView();
+			var layout2 = new StackLayout { FlowDirection = FlowDirection.LeftToRight, Children = { (View)view } };
+			var layout = new StackLayout { FlowDirection = FlowDirection.RightToLeft, Children = { layout2 } };
+
+			var target = view.EffectiveFlowDirection;
+
+			Assume.That(((IViewController)layout).EffectiveFlowDirection.IsExplicit());
+			Assume.That(((IViewController)layout).EffectiveFlowDirection.IsRightToLeft());
+
+			Assume.That(((IViewController)layout2).EffectiveFlowDirection.IsExplicit());
+			Assume.That(((IViewController)layout2).EffectiveFlowDirection.IsLeftToRight());
+
+			Assert.IsTrue(target.IsImplicit(), "EffectiveFlowDirection should be Implicit");
+			Assert.IsTrue(!target.IsExplicit(), "EffectiveFlowDirection should be Implicit");
+			Assert.IsTrue(!target.IsRightToLeft(), "EffectiveFlowDirection should be LeftToRight");
+			Assert.IsTrue(target.IsLeftToRight(), "EffectiveFlowDirection should be LeftToRight");
+		}
+
+		[Test]
+		public void SetParentAndGrandchildrenInheritValue()
+		{
+			var layout = ExplicitRightToLeftLayout();
+			var layout2 = ImplicitLeftToRightLayout();
+			IViewController view = ImplicitLeftToRightView();
+
+			AddImplicitToRTL(layout, layout2);
+
+			AddImplicitToRTL(layout2, (View)view);
+
+			var target = view.EffectiveFlowDirection;
+
+			Assert.IsTrue(target.IsImplicit(), "EffectiveFlowDirection should be Implicit");
+			Assert.IsTrue(!target.IsExplicit(), "EffectiveFlowDirection should be Implicit");
+			Assert.IsTrue(target.IsRightToLeft(), "EffectiveFlowDirection should be RightToLeft");
+			Assert.IsTrue(!target.IsLeftToRight(), "EffectiveFlowDirection should be RightToLeft");
+		}
+
+		[Test]
+		public void SetParentAndContentAndGrandchildrenInheritValue()
+		{
+			var layout = ExplicitRightToLeftLayout();
+			var layout2 = ImplicitLeftToRightScrollView();
+			IViewController view = ImplicitLeftToRightView();
+
+			AddImplicitToRTL(layout, layout2);
+
+			AddImplicitToRTLScrollView(layout2, (View)view);
+
+			var target = view.EffectiveFlowDirection;
+
+			Assert.IsTrue(target.IsImplicit(), "EffectiveFlowDirection should be Implicit");
+			Assert.IsTrue(!target.IsExplicit(), "EffectiveFlowDirection should be Implicit");
+			Assert.IsTrue(target.IsRightToLeft(), "EffectiveFlowDirection should be RightToLeft");
+			Assert.IsTrue(!target.IsLeftToRight(), "EffectiveFlowDirection should be RightToLeft");
+		}
+
+
+		[Test]
+		public void SetParentAndInheritExplicitParentValue()
+		{
+			var layout = ExplicitRightToLeftLayout();
+			IViewController view = ImplicitLeftToRightView();
+
+			AddImplicitToRTL(layout, (View)view);
+
+			var target = view.EffectiveFlowDirection;
+
+			Assert.IsTrue(target.IsImplicit(), "EffectiveFlowDirection should be Implicit");
+			Assert.IsTrue(!target.IsExplicit(), "EffectiveFlowDirection should be Implicit");
+			Assert.IsTrue(target.IsRightToLeft(), "EffectiveFlowDirection should be RightToLeft");
+			Assert.IsTrue(!target.IsLeftToRight(), "EffectiveFlowDirection should be RightToLeft");
+		}
+
+		[Test]
+		public void SetParentAndMaintainExplicitValue()
+		{
+			var layout = ExplicitRightToLeftLayout();
+			IViewController view = ExplicitLeftToRightView();
+
+			AddExplicitLTRToLayout(layout, (View)view);
+
+			var target = view.EffectiveFlowDirection;
+
+			Assert.IsTrue(!target.IsImplicit(), "EffectiveFlowDirection should be Explicit");
+			Assert.IsTrue(target.IsExplicit(), "EffectiveFlowDirection should be Explicit");
+			Assert.IsTrue(!target.IsRightToLeft(), "EffectiveFlowDirection should be LeftToRight");
+			Assert.IsTrue(target.IsLeftToRight(), "EffectiveFlowDirection should be LeftToRight");
+			Assert.AreEqual(FlowDirection.LeftToRight, ((View)view).FlowDirection);
+		}
+
+		[Test]
+		public void SetParentUsingCtorAndInheritParentValue()
+		{
+			IViewController view = ImplicitLeftToRightView();
+			var layout = new StackLayout { FlowDirection = FlowDirection.RightToLeft, Children = { (View)view } };
+
+			Assume.That(((IViewController)layout).EffectiveFlowDirection.IsExplicit());
+			Assume.That(((IViewController)layout).EffectiveFlowDirection.IsRightToLeft());
+
+			Assume.That(((View)view).FlowDirection == FlowDirection.MatchParent);
+
+			var target = view.EffectiveFlowDirection;
+
+			Assert.IsTrue(target.IsImplicit(), "EffectiveFlowDirection should be Implicit");
+			Assert.IsTrue(!target.IsExplicit(), "EffectiveFlowDirection should be Implicit");
+			Assert.IsTrue(target.IsRightToLeft(), "EffectiveFlowDirection should be RightToLeft");
+			Assert.IsTrue(!target.IsLeftToRight(), "EffectiveFlowDirection should be RightToLeft");
+			Assert.AreEqual(FlowDirection.MatchParent, ((View)view).FlowDirection);
+		}
+
+		[SetUp]
+		public override void Setup()
+		{
+			base.Setup();
+			Device.PlatformServices = new MockPlatformServices();
+		}
+
+		[TearDown]
+		public override void TearDown()
+		{
+			base.TearDown();
+			Device.PlatformServices = null;
+		}
+
+		static void AddExplicitLTRToScrollView(ScrollView parent, View child)
+		{
+			parent.Content = child;
+
+			IViewController controller = child;
+
+			Assume.That(controller.EffectiveFlowDirection.IsExplicit(), "child view FlowDirection should be Explicit");
+			Assume.That(controller.EffectiveFlowDirection.IsLeftToRight(), "child view FlowDirection should be LeftToRight");
+			Assume.That(child.FlowDirection == FlowDirection.LeftToRight, "child view FlowDirection should be LeftToRight");
+		}
+
+		static void AddExplicitLTRToLayout(StackLayout parent, View child)
+		{
+			parent.Children.Add(child);
+
+			IViewController controller = child;
+
+			Assume.That(controller.EffectiveFlowDirection.IsExplicit(), "child view FlowDirection should be Explicit");
+			Assume.That(controller.EffectiveFlowDirection.IsLeftToRight(), "child view FlowDirection should be LeftToRight");
+			Assume.That(child.FlowDirection == FlowDirection.LeftToRight, "child view FlowDirection should be LeftToRight");
+		}
+
+		static void AddExplicitRTLToScrollView(ScrollView parent, View child)
+		{
+			parent.Content = child;
+
+			IViewController controller = child;
+
+			Assume.That(controller.EffectiveFlowDirection.IsExplicit(), "child view EffectiveFlowDirection should be Implicit");
+			Assume.That(controller.EffectiveFlowDirection.IsRightToLeft(), "child view EffectiveFlowDirection should be RightToLeft");
+			Assume.That(child.FlowDirection == FlowDirection.RightToLeft, "child view FlowDirection should be RightToLeft");
+		}
+
+		static void AddExplicitRTLToLayout(StackLayout parent, View child)
+		{
+			parent.Children.Add(child);
+
+			IViewController controller = child;
+
+			Assume.That(controller.EffectiveFlowDirection.IsExplicit(), "child view EffectiveFlowDirection should be Implicit");
+			Assume.That(controller.EffectiveFlowDirection.IsRightToLeft(), "child view EffectiveFlowDirection should be RightToLeft");
+			Assume.That(child.FlowDirection == FlowDirection.RightToLeft, "child view FlowDirection should be RightToLeft");
+		}
+
+		static void AddImplicitToLTR(StackLayout parent, View child)
+		{
+			parent.Children.Add(child);
+
+			IViewController controller = child;
+
+			Assume.That(controller.EffectiveFlowDirection.IsImplicit(), "child view EffectiveFlowDirection should be Implicit");
+			Assume.That(controller.EffectiveFlowDirection.IsLeftToRight(), "child view EffectiveFlowDirection should be LeftToRight");
+			Assume.That(child.FlowDirection == FlowDirection.MatchParent, "child view FlowDirection should be MatchParent");
+		}
+
+		static void AddImplicitToLTRScrollView(ScrollView parent, View child)
+		{
+			parent.Content = child;
+
+			IViewController controller = child;
+
+			Assume.That(controller.EffectiveFlowDirection.IsImplicit(), "child view EffectiveFlowDirection should be Implicit");
+			Assume.That(controller.EffectiveFlowDirection.IsLeftToRight(), "child view EffectiveFlowDirection should be LeftToRight");
+			Assume.That(child.FlowDirection == FlowDirection.MatchParent, "child view FlowDirection should be MatchParent");
+		}
+
+		static void AddImplicitToRTL(StackLayout parent, View child)
+		{
+			parent.Children.Add(child);
+
+			IViewController controller = child;
+
+			Assume.That(controller.EffectiveFlowDirection.IsImplicit(), "child view EffectiveFlowDirection should be Implicit");
+			Assume.That(controller.EffectiveFlowDirection.IsRightToLeft(), "child view EffectiveFlowDirection should be RightToLeft");
+			Assume.That(child.FlowDirection == FlowDirection.MatchParent, "child view FlowDirection should be MatchParent");
+		}
+
+		static void AddImplicitToRTLScrollView(ScrollView parent, View child)
+		{
+			parent.Content = child;
+
+			IViewController controller = child;
+
+			Assume.That(controller.EffectiveFlowDirection.IsImplicit(), "child view EffectiveFlowDirection should be Implicit");
+			Assume.That(controller.EffectiveFlowDirection.IsRightToLeft(), "child view EffectiveFlowDirection should be RightToLeft");
+			Assume.That(child.FlowDirection == FlowDirection.MatchParent, "child view FlowDirection should be MatchParent");
+		}
+
+		static ScrollView ExplicitLeftToRightScrollView()
+		{
+			var layout = new ScrollView { FlowDirection = FlowDirection.LeftToRight };
+
+			IViewController controller = layout;
+
+			Assume.That(controller.EffectiveFlowDirection.IsExplicit(), "Explicit LTR view EffectiveFlowDirection should be Explicit");
+			Assume.That(controller.EffectiveFlowDirection.IsLeftToRight(), "Explicit LTR view EffectiveFlowDirection should be LeftToRight");
+			Assume.That(layout.FlowDirection == FlowDirection.LeftToRight, "Explicit LTR view FlowDirection should be LeftToRight");
+			return layout;
+		}
+
+		static StackLayout ExplicitLeftToRightLayout()
+		{
+			var layout = new StackLayout { FlowDirection = FlowDirection.LeftToRight };
+
+			IViewController controller = layout;
+
+			Assume.That(controller.EffectiveFlowDirection.IsExplicit(), "Explicit LTR view EffectiveFlowDirection should be Explicit");
+			Assume.That(controller.EffectiveFlowDirection.IsLeftToRight(), "Explicit LTR view EffectiveFlowDirection should be LeftToRight");
+			Assume.That(layout.FlowDirection == FlowDirection.LeftToRight, "Explicit LTR view FlowDirection should be LeftToRight");
+			return layout;
+		}
+
+		static View ExplicitLeftToRightView()
+		{
+			var view = new View { FlowDirection = FlowDirection.LeftToRight };
+
+			IViewController controller = view;
+
+			Assume.That(controller.EffectiveFlowDirection.IsExplicit(), "Explicit LTR view EffectiveFlowDirection should be Explicit");
+			Assume.That(controller.EffectiveFlowDirection.IsLeftToRight(), "Explicit LTR view EffectiveFlowDirection should be LeftToRight");
+			Assume.That(((View)view).FlowDirection == FlowDirection.LeftToRight, "Explicit LTR view FlowDirection should be LeftToRight");
+
+			return view;
+		}
+
+		static ScrollView ExplicitRightToLeftScrollView()
+		{
+			var layout = new ScrollView { FlowDirection = FlowDirection.RightToLeft };
+
+			IViewController controller = layout;
+
+			Assume.That(controller.EffectiveFlowDirection.IsExplicit(), "Explicit RTL view EffectiveFlowDirection should be Explicit");
+			Assume.That(controller.EffectiveFlowDirection.IsRightToLeft(), "Explicit RTL view EffectiveFlowDirection should be RightToLeft");
+			Assume.That(layout.FlowDirection == FlowDirection.RightToLeft, "Explicit RTL view FlowDirection should be RightToLeft");
+
+			return layout;
+		}
+
+		static StackLayout ExplicitRightToLeftLayout()
+		{
+			var layout = new StackLayout { FlowDirection = FlowDirection.RightToLeft };
+
+			IViewController controller = layout;
+
+			Assume.That(controller.EffectiveFlowDirection.IsExplicit(), "Explicit RTL view EffectiveFlowDirection should be Explicit");
+			Assume.That(controller.EffectiveFlowDirection.IsRightToLeft(), "Explicit RTL view EffectiveFlowDirection should be RightToLeft");
+			Assume.That(layout.FlowDirection == FlowDirection.RightToLeft, "Explicit RTL view FlowDirection should be RightToLeft");
+
+			return layout;
+		}
+
+		static View ExplicitRightToLeftView()
+		{
+			var view = new View { FlowDirection = FlowDirection.RightToLeft };
+
+			IViewController controller = view;
+
+			Assume.That(controller.EffectiveFlowDirection.IsExplicit(), "Explicit RTL view EffectiveFlowDirection should be Explicit");
+			Assume.That(controller.EffectiveFlowDirection.IsRightToLeft(), "Explicit RTL view EffectiveFlowDirection should be RightToLeft");
+			Assume.That(((View)view).FlowDirection == FlowDirection.RightToLeft, "Explicit RTL view FlowDirection should be RightToLeft");
+
+			return view;
+		}
+
+		static ScrollView ImplicitLeftToRightScrollView()
+		{
+			var layout = new ScrollView();
+
+			IViewController controller = layout;
+
+			Assume.That(controller.EffectiveFlowDirection.IsImplicit(), "New view EffectiveFlowDirection should be Implicit");
+			Assume.That(controller.EffectiveFlowDirection.IsLeftToRight(), "New view EffectiveFlowDirection should be LeftToRight");
+			Assume.That(layout.FlowDirection == FlowDirection.MatchParent, "New view FlowDirection should be MatchParent");
+
+			return layout;
+		}
+
+		static StackLayout ImplicitLeftToRightLayout()
+		{
+			var layout = new StackLayout();
+
+			IViewController controller = layout;
+
+			Assume.That(controller.EffectiveFlowDirection.IsImplicit(), "New view EffectiveFlowDirection should be Implicit");
+			Assume.That(controller.EffectiveFlowDirection.IsLeftToRight(), "New view EffectiveFlowDirection should be LeftToRight");
+			Assume.That(layout.FlowDirection == FlowDirection.MatchParent, "New view FlowDirection should be MatchParent");
+
+			return layout;
+		}
+
+		static View ImplicitLeftToRightView()
+		{
+			var view = new View();
+
+			IViewController controller = view;
+
+			Assume.That(controller.EffectiveFlowDirection.IsImplicit(), "New view EffectiveFlowDirection should be Implicit");
+			Assume.That(controller.EffectiveFlowDirection.IsLeftToRight(), "New view EffectiveFlowDirection should be LeftToRight");
+			Assume.That(((View)view).FlowDirection == FlowDirection.MatchParent, "New view FlowDirection should be MatchParent");
+
+			return view;
+		}
+
+		class PropertyWatchingView : View
+		{
+			public int FlowDirectionPropertyChangedCount { get; private set; }
+
+			protected override void OnPropertyChanged([CallerMemberName] string propertyName = null)
+			{
+				base.OnPropertyChanged(propertyName);
+
+				if (propertyName == View.FlowDirectionProperty.PropertyName)
+					FlowDirectionPropertyChangedCount++;
+			}
+		}
+	}
+}
\ No newline at end of file
diff --git a/Xamarin.Forms.Core.UnitTests/LayoutChildIntoBoundingRegionTests.cs b/Xamarin.Forms.Core.UnitTests/LayoutChildIntoBoundingRegionTests.cs
new file mode 100644
index 00000000000..fcc15d7f7cb
--- /dev/null
+++ b/Xamarin.Forms.Core.UnitTests/LayoutChildIntoBoundingRegionTests.cs
@@ -0,0 +1,844 @@
+using NUnit.Framework;
+using System;
+
+namespace Xamarin.Forms.Core.UnitTests
+{
+	[TestFixture]
+	public class LayoutChildIntoBoundingRegionTests : BaseTestFixture
+	{
+		const int Layout_Width = 100;
+		const int Margin_Large = 12;
+		const int Margin_None = 0;
+		const int Margin_Small = 2;
+		const int Region_Height = 50;
+		const int Region_Width = 150;
+		const int Region_X = 5;
+		const int Region_Y = 5;
+		const int View_Size = 20;
+
+		int Expected_Empty_Region_Height => Region_Height - View_Size;
+		int Expected_Empty_Region_Width => Region_Width - View_Size;
+		int Expected_Height_Start_End => View_Size;
+		int Expected_Region_Right => Region_X + Region_Width;
+		int Expected_Width_Start_End => View_Size;
+		int Expected_X_Center => Expected_Empty_Region_Width / 2 + Region_X;
+		int Expected_Y_Center => Expected_Empty_Region_Height / 2 + Region_Y;
+
+		[TestCase(Margin_None)]
+		[TestCase(Margin_Small)]
+		[TestCase(Margin_Large)]
+		public void Default(int margin)
+		{
+			var layout = new StackLayout();
+			layout.MockBounds(new Rectangle(0, 0, Layout_Width, double.PositiveInfinity));
+
+			var view = new MockView(margin);
+
+			layout.Children.Add(view);
+			var region = new Rectangle(Region_X, Region_Y, Region_Width, Region_Height);
+
+			Layout.LayoutChildIntoBoundingRegion(view, region);
+
+			var target = view.Bounds;
+			var thickness = margin * 2;
+
+			Assume.That(view.HorizontalOptions.Alignment == LayoutAlignment.Fill,
+					"view.HorizontalOptions.Alignment should be Fill");
+			Assume.That(view.VerticalOptions.Alignment == LayoutAlignment.Fill,
+					"view.VerticalOptions.Alignment should be Fill");
+
+			Assert.AreEqual(Expected_X_Fill_Plus_Margin(margin), target.X, "X");
+			Assert.AreEqual(Expected_Y_Fill_Plus_Margin(margin), target.Y, "Y");
+			Assert.AreEqual(Expected_Width_Fill_Less_Thickness(thickness), target.Width, "Width");
+			Assert.AreEqual(Expected_Height_Fill_Less_Thickness(thickness), target.Height, "Height");
+		}
+
+		[TestCase(Margin_None)]
+		[TestCase(Margin_Small)]
+		[TestCase(Margin_Large)]
+		public void Default_RTL(int margin)
+		{
+			var layout = new StackLayout { FlowDirection = FlowDirection.RightToLeft };
+			layout.MockBounds(new Rectangle(0, 0, Layout_Width, double.PositiveInfinity));
+
+			var view = new MockView(margin);
+
+			layout.Children.Add(view);
+
+			var region = new Rectangle(Region_X, Region_Y, Region_Width, Region_Height);
+
+			Layout.LayoutChildIntoBoundingRegion(view, region);
+
+			var target = view.Bounds;
+			var thickness = margin * 2;
+
+			Assume.That(view.HorizontalOptions.Alignment == LayoutAlignment.Fill,
+					"view.HorizontalOptions.Alignment should be Fill");
+			Assume.That(view.VerticalOptions.Alignment == LayoutAlignment.Fill,
+					"view.VerticalOptions.Alignment should be Fill");
+
+			Assert.AreEqual(Expected_Region_Right, region.Right, "region.Right");
+			Assert.AreEqual(Layout_Width, layout.Width, "layout.Width");
+
+			Assert.AreEqual(Expected_X_Fill_RTL_Plus_Margin(margin), target.X, "X");
+			Assert.AreEqual(Expected_Y_Fill_Plus_Margin(margin), target.Y, "Y");
+			Assert.AreEqual(Expected_Width_Fill_Less_Thickness(thickness), target.Width, "Width");
+			Assert.AreEqual(Expected_Height_Fill_Less_Thickness(thickness), target.Height, "Height");
+		}
+
+		[TestCase(Margin_None)]
+		[TestCase(Margin_Small)]
+		[TestCase(Margin_Large)]
+		public void HorizontalCenter(int margin)
+		{
+			var layout = new StackLayout();
+			layout.MockBounds(new Rectangle(0, 0, Layout_Width, double.PositiveInfinity));
+
+			var view = new MockView(margin) { HorizontalOptions = LayoutOptions.Center };
+
+			layout.Children.Add(view);
+			var region = new Rectangle(Region_X, Region_Y, Region_Width, Region_Height);
+
+			Layout.LayoutChildIntoBoundingRegion(view, region);
+
+			var target = view.Bounds;
+			var thickness = margin * 2;
+
+			Assume.That(view.HorizontalOptions.Alignment == LayoutAlignment.Center,
+					"view.HorizontalOptions.Alignment should be Center");
+			Assume.That(view.HorizontalOptions.Alignment.ToDouble() == 0.5,
+					"view.HorizontalOptions.Alignment.ToDouble() should be 0.5");
+			Assume.That(view.VerticalOptions.Alignment == LayoutAlignment.Fill,
+					"view.VerticalOptions.Alignment should be Fill");
+
+			Assert.AreEqual(Expected_X_Center, target.X, "X");
+			Assert.AreEqual(Expected_Y_Fill_Plus_Margin(margin), target.Y, "Y");
+			Assert.AreEqual(Expected_Width_Start_End, target.Width, "Width");
+			Assert.AreEqual(Expected_Height_Fill_Less_Thickness(thickness), target.Height, "Height");
+		}
+
+		[TestCase(Margin_None)]
+		[TestCase(Margin_Small)]
+		[TestCase(Margin_Large)]
+		public void HorizontalCenter_RTL(int margin)
+		{
+			var layout = new StackLayout { FlowDirection = FlowDirection.RightToLeft };
+			layout.MockBounds(new Rectangle(0, 0, Layout_Width, double.PositiveInfinity));
+
+			var view = new MockView(margin) { HorizontalOptions = LayoutOptions.Center };
+
+			layout.Children.Add(view);
+			var region = new Rectangle(Region_X, Region_Y, Region_Width, Region_Height);
+
+			Layout.LayoutChildIntoBoundingRegion(view, region);
+
+			var target = view.Bounds;
+			var thickness = margin * 2;
+			var center_margin = Math.Ceiling(margin / 2d);
+
+			Assume.That(view.HorizontalOptions.Alignment == LayoutAlignment.Center,
+					"view.HorizontalOptions.Alignment should be Center");
+			Assume.That(view.HorizontalOptions.Alignment.ToDouble() == 0.5,
+					"view.HorizontalOptions.Alignment.ToDouble() should be 0.5");
+			Assume.That(view.VerticalOptions.Alignment == LayoutAlignment.Fill,
+					"view.VerticalOptions.Alignment should be Fill");
+
+			Assert.AreEqual(Expected_X_Center_RTL_Plus_Margin(0), target.X, "X");
+			Assert.AreEqual(Expected_Y_Fill_Plus_Margin(margin), target.Y, "Y");
+			Assert.AreEqual(Expected_Width_Start_End, target.Width, "Width");
+			Assert.AreEqual(Expected_Height_Fill_Less_Thickness(thickness), target.Height, "Height");
+		}
+
+		[TestCase(Margin_None)]
+		[TestCase(Margin_Small)]
+		[TestCase(Margin_Large)]
+		public void HorizontalCenterAndExpand(int margin)
+		{
+			var layout = new StackLayout();
+			layout.MockBounds(new Rectangle(0, 0, Layout_Width, double.PositiveInfinity));
+			var view = new MockView(margin) { HorizontalOptions = LayoutOptions.CenterAndExpand };
+
+			layout.Children.Add(view);
+			var region = new Rectangle(Region_X, Region_Y, Region_Width, Region_Height);
+
+			Layout.LayoutChildIntoBoundingRegion(view, region);
+
+			var target = view.Bounds;
+			var thickness = margin * 2;
+
+			Assume.That(view.HorizontalOptions.Alignment == LayoutAlignment.Center,
+					"view.HorizontalOptions.Alignment should be Center");
+			Assume.That(view.HorizontalOptions.Alignment.ToDouble() == 0.5,
+					"view.HorizontalOptions.Alignment.ToDouble() should be 0.5");
+			Assume.That(view.VerticalOptions.Alignment == LayoutAlignment.Fill,
+					"view.VerticalOptions.Alignment should be Fill");
+
+			Assert.AreEqual(Expected_X_Center, target.X, "X");
+			Assert.AreEqual(Expected_Y_Fill_Plus_Margin(margin), target.Y, "Y");
+			Assert.AreEqual(Expected_Width_Start_End, target.Width, "Width");
+			Assert.AreEqual(Expected_Height_Fill_Less_Thickness(thickness), target.Height, "Height");
+		}
+
+		[TestCase(Margin_None)]
+		[TestCase(Margin_Small)]
+		[TestCase(Margin_Large)]
+		public void HorizontalCenterAndExpand_RTL(int margin)
+		{
+			var layout = new StackLayout { FlowDirection = FlowDirection.RightToLeft };
+			layout.MockBounds(new Rectangle(0, 0, Layout_Width, double.PositiveInfinity));
+			var view = new MockView(margin) { HorizontalOptions = LayoutOptions.CenterAndExpand };
+
+			layout.Children.Add(view);
+			var region = new Rectangle(Region_X, Region_Y, Region_Width, Region_Height);
+
+			Layout.LayoutChildIntoBoundingRegion(view, region);
+
+			var target = view.Bounds;
+			var thickness = margin * 2;
+
+			Assume.That(view.HorizontalOptions.Alignment == LayoutAlignment.Center,
+					"view.HorizontalOptions.Alignment should be Center");
+			Assume.That(view.HorizontalOptions.Alignment.ToDouble() == 0.5,
+					"view.HorizontalOptions.Alignment.ToDouble() should be 0.5");
+			Assume.That(view.VerticalOptions.Alignment == LayoutAlignment.Fill,
+					"view.VerticalOptions.Alignment should be Fill");
+
+			Assert.AreEqual(Expected_X_Center_RTL_Plus_Margin(0), target.X, "X");
+			Assert.AreEqual(Expected_Y_Fill_Plus_Margin(margin), target.Y, "Y");
+			Assert.AreEqual(Expected_Width_Start_End, target.Width, "Width");
+			Assert.AreEqual(Expected_Height_Fill_Less_Thickness(thickness), target.Height, "Height");
+		}
+
+		[TestCase(Margin_None)]
+		[TestCase(Margin_Small)]
+		[TestCase(Margin_Large)]
+		public void HorizontalEnd(int margin)
+		{
+			var layout = new StackLayout();
+			layout.MockBounds(new Rectangle(0, 0, Layout_Width, double.PositiveInfinity));
+			var view = new MockView(margin) { HorizontalOptions = LayoutOptions.End };
+
+			layout.Children.Add(view);
+			var region = new Rectangle(Region_X, Region_Y, Region_Width, Region_Height);
+
+			Layout.LayoutChildIntoBoundingRegion(view, region);
+
+			var target = view.Bounds;
+			var thickness = margin * 2;
+
+			Assume.That(view.HorizontalOptions.Alignment == LayoutAlignment.End,
+					"view.HorizontalOptions.Alignment should be End");
+			Assume.That(view.HorizontalOptions.Alignment.ToDouble() == 1,
+					"view.HorizontalOptions.Alignment.ToDouble() should be 1");
+			Assume.That(view.VerticalOptions.Alignment == LayoutAlignment.Fill,
+					"view.VerticalOptions.Alignment should be Fill");
+
+			Assert.AreEqual(Expected_X_End_Less_Margin(margin), target.X, "X");
+			Assert.AreEqual(Expected_Y_Fill_Plus_Margin(margin), target.Y, "Y");
+			Assert.AreEqual(Expected_Width_Start_End, target.Width, "Width");
+			Assert.AreEqual(Expected_Height_Fill_Less_Thickness(thickness), target.Height, "Height");
+		}
+
+		[TestCase(Margin_None)]
+		[TestCase(Margin_Small)]
+		[TestCase(Margin_Large)]
+		public void HorizontalEnd_RTL(int margin)
+		{
+			var layout = new StackLayout { FlowDirection = FlowDirection.RightToLeft };
+			layout.MockBounds(new Rectangle(0, 0, Layout_Width, double.PositiveInfinity));
+			var view = new MockView(margin) { HorizontalOptions = LayoutOptions.End };
+
+			layout.Children.Add(view);
+			var region = new Rectangle(Region_X, Region_Y, Region_Width, Region_Height);
+
+			Layout.LayoutChildIntoBoundingRegion(view, region);
+
+			var target = view.Bounds;
+			var thickness = margin * 2;
+
+			Assume.That(view.HorizontalOptions.Alignment == LayoutAlignment.End,
+					"view.HorizontalOptions.Alignment should be End");
+			Assume.That(view.HorizontalOptions.Alignment.ToDouble() == 1,
+					"view.HorizontalOptions.Alignment.ToDouble() should be 1");
+			Assume.That(view.VerticalOptions.Alignment == LayoutAlignment.Fill,
+					"view.VerticalOptions.Alignment should be Fill");
+
+			Assert.AreEqual(Expected_X_End_RTL_Plus_Margin(margin), target.X, "X");
+			Assert.AreEqual(Expected_Y_Fill_Plus_Margin(margin), target.Y, "Y");
+			Assert.AreEqual(Expected_Width_Start_End, target.Width, "Width");
+			Assert.AreEqual(Expected_Height_Fill_Less_Thickness(thickness), target.Height, "Height");
+		}
+
+		[TestCase(Margin_None)]
+		[TestCase(Margin_Small)]
+		[TestCase(Margin_Large)]
+		public void HorizontalEndAndExpand(int margin)
+		{
+			var layout = new StackLayout();
+			layout.MockBounds(new Rectangle(0, 0, Layout_Width, double.PositiveInfinity));
+			var view = new MockView(margin) { HorizontalOptions = LayoutOptions.EndAndExpand };
+
+			layout.Children.Add(view);
+			var region = new Rectangle(Region_X, Region_Y, Region_Width, Region_Height);
+
+			Layout.LayoutChildIntoBoundingRegion(view, region);
+
+			var target = view.Bounds;
+			var thickness = margin * 2;
+
+			Assume.That(view.HorizontalOptions.Alignment == LayoutAlignment.End,
+					"view.HorizontalOptions.Alignment should be End");
+			Assume.That(view.HorizontalOptions.Alignment.ToDouble() == 1,
+					"view.HorizontalOptions.Alignment.ToDouble() should be 1");
+			Assume.That(view.VerticalOptions.Alignment == LayoutAlignment.Fill,
+					"view.VerticalOptions.Alignment should be Fill");
+
+			Assert.AreEqual(Expected_X_End_Less_Margin(margin), target.X, "X");
+			Assert.AreEqual(Expected_Y_Fill_Plus_Margin(margin), target.Y, "Y");
+			Assert.AreEqual(Expected_Width_Start_End, target.Width, "Width");
+			Assert.AreEqual(Expected_Height_Fill_Less_Thickness(thickness), target.Height, "Height");
+		}
+
+		[TestCase(Margin_None)]
+		[TestCase(Margin_Small)]
+		[TestCase(Margin_Large)]
+		public void HorizontalEndAndExpand_RTL(int margin)
+		{
+			var layout = new StackLayout { FlowDirection = FlowDirection.RightToLeft };
+			layout.MockBounds(new Rectangle(0, 0, Layout_Width, double.PositiveInfinity));
+			var view = new MockView(margin) { HorizontalOptions = LayoutOptions.EndAndExpand };
+
+			layout.Children.Add(view);
+			var region = new Rectangle(Region_X, Region_Y, Region_Width, Region_Height);
+
+			Layout.LayoutChildIntoBoundingRegion(view, region);
+
+			var target = view.Bounds;
+			var thickness = margin * 2;
+
+			Assume.That(view.HorizontalOptions.Alignment == LayoutAlignment.End,
+					"view.HorizontalOptions.Alignment should be End");
+			Assume.That(view.HorizontalOptions.Alignment.ToDouble() == 1,
+					"view.HorizontalOptions.Alignment.ToDouble() should be 1");
+			Assume.That(view.VerticalOptions.Alignment == LayoutAlignment.Fill,
+					"view.VerticalOptions.Alignment should be Fill");
+
+			Assert.AreEqual(Expected_X_End_RTL_Plus_Margin(margin), target.X, "X");
+			Assert.AreEqual(Expected_Y_Fill_Plus_Margin(margin), target.Y, "Y");
+			Assert.AreEqual(Expected_Width_Start_End, target.Width, "Width");
+			Assert.AreEqual(Expected_Height_Fill_Less_Thickness(thickness), target.Height, "Height");
+		}
+
+		[TestCase(Margin_None)]
+		[TestCase(Margin_Small)]
+		[TestCase(Margin_Large)]
+		public void HorizontalStart(int margin)
+		{
+			var layout = new StackLayout();
+			layout.MockBounds(new Rectangle(0, 0, Layout_Width, double.PositiveInfinity));
+			var view = new MockView(margin) { HorizontalOptions = LayoutOptions.Start };
+
+			layout.Children.Add(view);
+			var region = new Rectangle(Region_X, Region_Y, Region_Width, Region_Height);
+
+			Layout.LayoutChildIntoBoundingRegion(view, region);
+
+			var target = view.Bounds;
+			var thickness = margin * 2;
+
+			Assume.That(view.HorizontalOptions.Alignment == LayoutAlignment.Start,
+					"view.HorizontalOptions.Alignment should be Start");
+			Assume.That(view.HorizontalOptions.Alignment.ToDouble() == 0,
+					"view.HorizontalOptions.Alignment.ToDouble() should be 0");
+			Assume.That(view.VerticalOptions.Alignment == LayoutAlignment.Fill,
+					"view.VerticalOptions.Alignment should be Fill");
+
+			Assert.AreEqual(Expected_X_Fill_Plus_Margin(margin), target.X, "X");
+			Assert.AreEqual(Expected_Y_Fill_Plus_Margin(margin), target.Y, "Y");
+			Assert.AreEqual(Expected_Width_Start_End, target.Width, "Width");
+			Assert.AreEqual(Expected_Height_Fill_Less_Thickness(thickness), target.Height, "Height");
+		}
+
+		[TestCase(Margin_None)]
+		[TestCase(Margin_Small)]
+		[TestCase(Margin_Large)]
+		public void HorizontalStart_RTL(int margin)
+		{
+			var layout = new StackLayout { FlowDirection = FlowDirection.RightToLeft };
+			layout.MockBounds(new Rectangle(0, 0, Layout_Width, double.PositiveInfinity));
+			var view = new MockView(margin) { HorizontalOptions = LayoutOptions.Start };
+
+			layout.Children.Add(view);
+			var region = new Rectangle(Region_X, Region_Y, Region_Width, Region_Height);
+
+			Layout.LayoutChildIntoBoundingRegion(view, region);
+
+			var target = view.Bounds;
+			var thickness = margin * 2;
+
+			Assume.That(view.HorizontalOptions.Alignment == LayoutAlignment.Start,
+					"view.HorizontalOptions.Alignment should be Start");
+			Assume.That(view.HorizontalOptions.Alignment.ToDouble() == 0,
+					"view.HorizontalOptions.Alignment.ToDouble() should be 0");
+			Assume.That(view.VerticalOptions.Alignment == LayoutAlignment.Fill,
+					"view.VerticalOptions.Alignment should be Fill");
+
+			Assert.AreEqual(Expected_X_Start_Less_Margin(margin), target.X, "X");
+			Assert.AreEqual(Expected_Y_Fill_Plus_Margin(margin), target.Y, "Y");
+			Assert.AreEqual(Expected_Width_Start_End, target.Width, "Width");
+			Assert.AreEqual(Expected_Height_Fill_Less_Thickness(thickness), target.Height, "Height");
+		}
+
+		[TestCase(Margin_None)]
+		[TestCase(Margin_Small)]
+		[TestCase(Margin_Large)]
+		public void HorizontalStartAndExpand(int margin)
+		{
+			var layout = new StackLayout();
+			layout.MockBounds(new Rectangle(0, 0, Layout_Width, double.PositiveInfinity));
+			var view = new MockView(margin) { HorizontalOptions = LayoutOptions.StartAndExpand };
+
+			layout.Children.Add(view);
+			var region = new Rectangle(Region_X, Region_Y, Region_Width, Region_Height);
+
+			Layout.LayoutChildIntoBoundingRegion(view, region);
+
+			var target = view.Bounds;
+			var thickness = margin * 2;
+
+			Assume.That(view.HorizontalOptions.Alignment == LayoutAlignment.Start,
+					"view.HorizontalOptions.Alignment should be Start");
+			Assume.That(view.HorizontalOptions.Alignment.ToDouble() == 0,
+					"view.HorizontalOptions.Alignment.ToDouble() should be 0");
+			Assume.That(view.VerticalOptions.Alignment == LayoutAlignment.Fill,
+					"view.VerticalOptions.Alignment should be Fill");
+
+			Assert.AreEqual(Expected_X_Fill_Plus_Margin(margin), target.X, "X");
+			Assert.AreEqual(Expected_Y_Fill_Plus_Margin(margin), target.Y, "Y");
+			Assert.AreEqual(Expected_Width_Start_End, target.Width, "Width");
+			Assert.AreEqual(Expected_Height_Fill_Less_Thickness(thickness), target.Height, "Height");
+		}
+
+		[TestCase(Margin_None)]
+		[TestCase(Margin_Small)]
+		[TestCase(Margin_Large)]
+		public void HorizontalStartAndExpand_RTL(int margin)
+		{
+			var layout = new StackLayout { FlowDirection = FlowDirection.RightToLeft };
+			layout.MockBounds(new Rectangle(0, 0, Layout_Width, double.PositiveInfinity));
+			var view = new MockView(margin) { HorizontalOptions = LayoutOptions.StartAndExpand };
+
+			layout.Children.Add(view);
+			var region = new Rectangle(Region_X, Region_Y, Region_Width, Region_Height);
+
+			Layout.LayoutChildIntoBoundingRegion(view, region);
+
+			var target = view.Bounds;
+			var thickness = margin * 2;
+
+			Assume.That(view.HorizontalOptions.Alignment == LayoutAlignment.Start,
+					"view.HorizontalOptions.Alignment should be Start");
+			Assume.That(view.HorizontalOptions.Alignment.ToDouble() == 0,
+					"view.HorizontalOptions.Alignment.ToDouble() should be 0");
+			Assume.That(view.VerticalOptions.Alignment == LayoutAlignment.Fill,
+					"view.VerticalOptions.Alignment should be Fill");
+
+			Assert.AreEqual(Expected_X_Start_Less_Margin(margin), target.X, "X");
+			Assert.AreEqual(Expected_Y_Fill_Plus_Margin(margin), target.Y, "Y");
+			Assert.AreEqual(Expected_Width_Start_End, target.Width, "Width");
+			Assert.AreEqual(Expected_Height_Fill_Less_Thickness(thickness), target.Height, "Height");
+		}
+
+		[TestCase(Margin_None)]
+		[TestCase(Margin_Small)]
+		[TestCase(Margin_Large)]
+		public void VerticalCenter(int margin)
+		{
+			var layout = new StackLayout();
+			layout.MockBounds(new Rectangle(0, 0, Layout_Width, double.PositiveInfinity));
+
+			var view = new MockView(margin) { VerticalOptions = LayoutOptions.Center };
+
+			layout.Children.Add(view);
+			var region = new Rectangle(Region_X, Region_Y, Region_Width, Region_Height);
+
+			Layout.LayoutChildIntoBoundingRegion(view, region);
+
+			var target = view.Bounds;
+			var thickness = margin * 2;
+
+			Assume.That(view.VerticalOptions.Alignment == LayoutAlignment.Center,
+					"view.VerticalOptions.Alignment should be Center");
+			Assume.That(view.VerticalOptions.Alignment.ToDouble() == 0.5,
+					"view.VerticalOptions.Alignment.ToDouble() should be 0.5");
+			Assume.That(view.HorizontalOptions.Alignment == LayoutAlignment.Fill,
+					"view.HorizontalOptions.Alignment should be Fill");
+
+			Assert.AreEqual(Expected_X_Fill_Plus_Margin(margin), target.X, "X");
+			Assert.AreEqual(Expected_Y_Center, target.Y, "Y");
+			Assert.AreEqual(Expected_Width_Fill_Less_Thickness(thickness), target.Width, "Width");
+			Assert.AreEqual(Expected_Height_Start_End, target.Height, "Height");
+		}
+
+		[TestCase(Margin_None)]
+		[TestCase(Margin_Small)]
+		[TestCase(Margin_Large)]
+		public void VerticalCenter_RTL(int margin)
+		{
+			var layout = new StackLayout { FlowDirection = FlowDirection.RightToLeft };
+			layout.MockBounds(new Rectangle(0, 0, Layout_Width, double.PositiveInfinity));
+
+			var view = new MockView(margin) { VerticalOptions = LayoutOptions.Center };
+
+			layout.Children.Add(view);
+			var region = new Rectangle(Region_X, Region_Y, Region_Width, Region_Height);
+
+			Layout.LayoutChildIntoBoundingRegion(view, region);
+
+			var target = view.Bounds;
+			var thickness = margin * 2;
+
+			Assume.That(view.VerticalOptions.Alignment == LayoutAlignment.Center,
+					"view.VerticalOptions.Alignment should be Center");
+			Assume.That(view.VerticalOptions.Alignment.ToDouble() == 0.5,
+					"view.VerticalOptions.Alignment.ToDouble() should be 0.5");
+			Assume.That(view.HorizontalOptions.Alignment == LayoutAlignment.Fill,
+					"view.HorizontalOptions.Alignment should be Fill");
+
+			Assert.AreEqual(Expected_X_Fill_RTL_Plus_Margin(margin), target.X, "X");
+			Assert.AreEqual(Expected_Y_Center, target.Y, "Y");
+			Assert.AreEqual(Expected_Width_Fill_Less_Thickness(thickness), target.Width, "Width");
+			Assert.AreEqual(Expected_Height_Start_End, target.Height, "Height");
+		}
+
+		[TestCase(Margin_None)]
+		[TestCase(Margin_Small)]
+		[TestCase(Margin_Large)]
+		public void VerticalCenterAndExpand(int margin)
+		{
+			var layout = new StackLayout();
+			layout.MockBounds(new Rectangle(0, 0, Layout_Width, double.PositiveInfinity));
+			var view = new MockView(margin) { VerticalOptions = LayoutOptions.CenterAndExpand };
+
+			layout.Children.Add(view);
+			var region = new Rectangle(Region_X, Region_Y, Region_Width, Region_Height);
+
+			Layout.LayoutChildIntoBoundingRegion(view, region);
+
+			var target = view.Bounds;
+			var thickness = margin * 2;
+
+			Assume.That(view.VerticalOptions.Alignment == LayoutAlignment.Center,
+					"view.VerticalOptions.Alignment should be Center");
+			Assume.That(view.VerticalOptions.Alignment.ToDouble() == 0.5,
+					"view.VerticalOptions.Alignment.ToDouble() should be 0.5");
+			Assume.That(view.HorizontalOptions.Alignment == LayoutAlignment.Fill,
+					"view.HorizontalOptions.Alignment should be Fill");
+
+			Assert.AreEqual(Expected_X_Fill_Plus_Margin(margin), target.X, "X");
+			Assert.AreEqual(Expected_Y_Center, target.Y, "Y");
+			Assert.AreEqual(Expected_Width_Fill_Less_Thickness(thickness), target.Width, "Width");
+			Assert.AreEqual(Expected_Height_Start_End, target.Height, "Height");
+		}
+
+		[TestCase(Margin_None)]
+		[TestCase(Margin_Small)]
+		[TestCase(Margin_Large)]
+		public void VerticalCenterAndExpand_RTL(int margin)
+		{
+			var layout = new StackLayout { FlowDirection = FlowDirection.RightToLeft };
+			layout.MockBounds(new Rectangle(0, 0, Layout_Width, double.PositiveInfinity));
+			var view = new MockView(margin) { VerticalOptions = LayoutOptions.CenterAndExpand };
+
+			layout.Children.Add(view);
+			var region = new Rectangle(Region_X, Region_Y, Region_Width, Region_Height);
+
+			Layout.LayoutChildIntoBoundingRegion(view, region);
+
+			var target = view.Bounds;
+			var thickness = margin * 2;
+
+			Assume.That(view.VerticalOptions.Alignment == LayoutAlignment.Center,
+					"view.VerticalOptions.Alignment should be Center");
+			Assume.That(view.VerticalOptions.Alignment.ToDouble() == 0.5,
+					"view.VerticalOptions.Alignment.ToDouble() should be 0.5");
+			Assume.That(view.HorizontalOptions.Alignment == LayoutAlignment.Fill,
+					"view.HorizontalOptions.Alignment should be Fill");
+
+			Assert.AreEqual(Expected_X_Fill_RTL_Plus_Margin(margin), target.X, "X");
+			Assert.AreEqual(Expected_Y_Center, target.Y, "Y");
+			Assert.AreEqual(Expected_Width_Fill_Less_Thickness(thickness), target.Width, "Width");
+			Assert.AreEqual(Expected_Height_Start_End, target.Height, "Height");
+		}
+
+		[TestCase(Margin_None)]
+		[TestCase(Margin_Small)]
+		[TestCase(Margin_Large)]
+		public void VerticalEnd(int margin)
+		{
+			var layout = new StackLayout();
+			layout.MockBounds(new Rectangle(0, 0, Layout_Width, double.PositiveInfinity));
+			var view = new MockView(margin) { VerticalOptions = LayoutOptions.End };
+
+			layout.Children.Add(view);
+			var region = new Rectangle(Region_X, Region_Y, Region_Width, Region_Height);
+
+			Layout.LayoutChildIntoBoundingRegion(view, region);
+
+			var target = view.Bounds;
+			var thickness = margin * 2;
+
+			Assume.That(view.VerticalOptions.Alignment == LayoutAlignment.End,
+					"view.VerticalOptions.Alignment should be End");
+			Assume.That(view.VerticalOptions.Alignment.ToDouble() == 1,
+					"view.VerticalOptions.Alignment.ToDouble() should be 1");
+			Assume.That(view.HorizontalOptions.Alignment == LayoutAlignment.Fill,
+					"view.HorizontalOptions.Alignment should be Fill");
+
+			Assert.AreEqual(Expected_X_Fill_Plus_Margin(margin), target.X, "X");
+			Assert.AreEqual(Expected_Y_End_Less_Margin(margin), target.Y, "Y");
+			Assert.AreEqual(Expected_Width_Fill_Less_Thickness(thickness), target.Width, "Width");
+			Assert.AreEqual(Expected_Height_Start_End, target.Height, "Height");
+		}
+
+		[TestCase(Margin_None)]
+		[TestCase(Margin_Small)]
+		[TestCase(Margin_Large)]
+		public void VerticalEnd_RTL(int margin)
+		{
+			var layout = new StackLayout { FlowDirection = FlowDirection.RightToLeft };
+			layout.MockBounds(new Rectangle(0, 0, Layout_Width, double.PositiveInfinity));
+			var view = new MockView(margin) { VerticalOptions = LayoutOptions.End };
+
+			layout.Children.Add(view);
+			var region = new Rectangle(Region_X, Region_Y, Region_Width, Region_Height);
+
+			Layout.LayoutChildIntoBoundingRegion(view, region);
+
+			var target = view.Bounds;
+			var thickness = margin * 2;
+
+			Assume.That(view.VerticalOptions.Alignment == LayoutAlignment.End,
+					"view.VerticalOptions.Alignment should be End");
+			Assume.That(view.VerticalOptions.Alignment.ToDouble() == 1,
+					"view.VerticalOptions.Alignment.ToDouble() should be 1");
+			Assume.That(view.HorizontalOptions.Alignment == LayoutAlignment.Fill,
+					"view.HorizontalOptions.Alignment should be Fill");
+
+			Assert.AreEqual(Expected_X_Fill_RTL_Plus_Margin(margin), target.X, "X");
+			Assert.AreEqual(Expected_Y_End_Less_Margin(margin), target.Y, "Y");
+			Assert.AreEqual(Expected_Width_Fill_Less_Thickness(thickness), target.Width, "Width");
+			Assert.AreEqual(Expected_Height_Start_End, target.Height, "Height");
+		}
+
+		[TestCase(Margin_None)]
+		[TestCase(Margin_Small)]
+		[TestCase(Margin_Large)]
+		public void VerticalEndAndExpand(int margin)
+		{
+			var layout = new StackLayout();
+			layout.MockBounds(new Rectangle(0, 0, Layout_Width, double.PositiveInfinity));
+			var view = new MockView(margin) { VerticalOptions = LayoutOptions.EndAndExpand };
+
+			layout.Children.Add(view);
+			var region = new Rectangle(Region_X, Region_Y, Region_Width, Region_Height);
+
+			Layout.LayoutChildIntoBoundingRegion(view, region);
+
+			var target = view.Bounds;
+			var thickness = margin * 2;
+
+			Assume.That(view.VerticalOptions.Alignment == LayoutAlignment.End,
+					"view.VerticalOptions.Alignment should be End");
+			Assume.That(view.VerticalOptions.Alignment.ToDouble() == 1,
+					"view.VerticalOptions.Alignment.ToDouble() should be 1");
+			Assume.That(view.HorizontalOptions.Alignment == LayoutAlignment.Fill,
+					"view.HorizontalOptions.Alignment should be Fill");
+
+			Assert.AreEqual(Expected_X_Fill_Plus_Margin(margin), target.X, "X");
+			Assert.AreEqual(Expected_Y_End_Less_Margin(margin), target.Y, "Y");
+			Assert.AreEqual(Expected_Width_Fill_Less_Thickness(thickness), target.Width, "Width");
+			Assert.AreEqual(Expected_Height_Start_End, target.Height, "Height");
+		}
+
+		[TestCase(Margin_None)]
+		[TestCase(Margin_Small)]
+		[TestCase(Margin_Large)]
+		public void VerticalEndAndExpand_RTL(int margin)
+		{
+			var layout = new StackLayout { FlowDirection = FlowDirection.RightToLeft };
+			layout.MockBounds(new Rectangle(0, 0, Layout_Width, double.PositiveInfinity));
+			var view = new MockView(margin) { VerticalOptions = LayoutOptions.EndAndExpand };
+
+			layout.Children.Add(view);
+			var region = new Rectangle(Region_X, Region_Y, Region_Width, Region_Height);
+
+			Layout.LayoutChildIntoBoundingRegion(view, region);
+
+			var target = view.Bounds;
+			var thickness = margin * 2;
+
+			Assume.That(view.VerticalOptions.Alignment == LayoutAlignment.End,
+					"view.VerticalOptions.Alignment should be End");
+			Assume.That(view.VerticalOptions.Alignment.ToDouble() == 1,
+					"view.VerticalOptions.Alignment.ToDouble() should be 1");
+			Assume.That(view.HorizontalOptions.Alignment == LayoutAlignment.Fill,
+					"view.HorizontalOptions.Alignment should be Fill");
+
+			Assert.AreEqual(Expected_X_Fill_RTL_Plus_Margin(margin), target.X, "X");
+			Assert.AreEqual(Expected_Y_End_Less_Margin(margin), target.Y, "Y");
+			Assert.AreEqual(Expected_Width_Fill_Less_Thickness(thickness), target.Width, "Width");
+			Assert.AreEqual(Expected_Height_Start_End, target.Height, "Height");
+		}
+
+		[TestCase(Margin_None)]
+		[TestCase(Margin_Small)]
+		[TestCase(Margin_Large)]
+		public void VerticalStart(int margin)
+		{
+			var layout = new StackLayout();
+			layout.MockBounds(new Rectangle(0, 0, Layout_Width, double.PositiveInfinity));
+			var view = new MockView(margin) { VerticalOptions = LayoutOptions.Start };
+
+			layout.Children.Add(view);
+			var region = new Rectangle(Region_X, Region_Y, Region_Width, Region_Height);
+
+			Layout.LayoutChildIntoBoundingRegion(view, region);
+
+			var target = view.Bounds;
+			var thickness = margin * 2;
+
+			Assume.That(view.VerticalOptions.Alignment == LayoutAlignment.Start,
+					"view.VerticalOptions.Alignment should be Start");
+			Assume.That(view.VerticalOptions.Alignment.ToDouble() == 0,
+					"view.VerticalOptions.Alignment.ToDouble() should be 0");
+			Assume.That(view.HorizontalOptions.Alignment == LayoutAlignment.Fill,
+					"view.HorizontalOptions.Alignment should be Fill");
+
+			Assert.AreEqual(Expected_X_Fill_Plus_Margin(margin), target.X, "X");
+			Assert.AreEqual(Expected_Y_Fill_Plus_Margin(margin), target.Y, "Y");
+			Assert.AreEqual(Expected_Width_Fill_Less_Thickness(thickness), target.Width, "Width");
+			Assert.AreEqual(Expected_Height_Start_End, target.Height, "Height");
+		}
+
+		[TestCase(Margin_None)]
+		[TestCase(Margin_Small)]
+		[TestCase(Margin_Large)]
+		public void VerticalStart_RTL(int margin)
+		{
+			var layout = new StackLayout { FlowDirection = FlowDirection.RightToLeft };
+			layout.MockBounds(new Rectangle(0, 0, Layout_Width, double.PositiveInfinity));
+			var view = new MockView(margin) { VerticalOptions = LayoutOptions.Start };
+
+			layout.Children.Add(view);
+			var region = new Rectangle(Region_X, Region_Y, Region_Width, Region_Height);
+
+			Layout.LayoutChildIntoBoundingRegion(view, region);
+
+			var target = view.Bounds;
+			var thickness = margin * 2;
+
+			Assume.That(view.VerticalOptions.Alignment == LayoutAlignment.Start,
+					"view.VerticalOptions.Alignment should be Start");
+			Assume.That(view.VerticalOptions.Alignment.ToDouble() == 0,
+					"view.VerticalOptions.Alignment.ToDouble() should be 0");
+			Assume.That(view.HorizontalOptions.Alignment == LayoutAlignment.Fill,
+					"view.HorizontalOptions.Alignment should be Fill");
+
+			Assert.AreEqual(Expected_X_Fill_RTL_Plus_Margin(margin), target.X, "X");
+			Assert.AreEqual(Expected_Y_Fill_Plus_Margin(margin), target.Y, "Y");
+			Assert.AreEqual(Expected_Width_Fill_Less_Thickness(thickness), target.Width, "Width");
+			Assert.AreEqual(Expected_Height_Start_End, target.Height, "Height");
+		}
+
+		[TestCase(Margin_None)]
+		[TestCase(Margin_Small)]
+		[TestCase(Margin_Large)]
+		public void VerticalStartAndExpand(int margin)
+		{
+			var layout = new StackLayout();
+			layout.MockBounds(new Rectangle(0, 0, Layout_Width, double.PositiveInfinity));
+			var view = new MockView(margin) { VerticalOptions = LayoutOptions.StartAndExpand };
+
+			layout.Children.Add(view);
+			var region = new Rectangle(Region_X, Region_Y, Region_Width, Region_Height);
+
+			Layout.LayoutChildIntoBoundingRegion(view, region);
+
+			var target = view.Bounds;
+			var thickness = margin * 2;
+
+			Assume.That(view.VerticalOptions.Alignment == LayoutAlignment.Start,
+					"view.VerticalOptions.Alignment should be Start");
+			Assume.That(view.VerticalOptions.Alignment.ToDouble() == 0,
+					"view.VerticalOptions.Alignment.ToDouble() should be 0");
+			Assume.That(view.HorizontalOptions.Alignment == LayoutAlignment.Fill,
+					"view.HorizontalOptions.Alignment should be Fill");
+
+			Assert.AreEqual(Expected_X_Fill_Plus_Margin(margin), target.X, "X");
+			Assert.AreEqual(Expected_Y_Fill_Plus_Margin(margin), target.Y, "Y");
+			Assert.AreEqual(Expected_Width_Fill_Less_Thickness(thickness), target.Width, "Width");
+			Assert.AreEqual(Expected_Height_Start_End, target.Height, "Height");
+		}
+
+		[TestCase(Margin_None)]
+		[TestCase(Margin_Small)]
+		[TestCase(Margin_Large)]
+		public void VerticalStartAndExpand_RTL(int margin)
+		{
+			var layout = new StackLayout { FlowDirection = FlowDirection.RightToLeft };
+			layout.MockBounds(new Rectangle(0, 0, Layout_Width, double.PositiveInfinity));
+			var view = new MockView(margin) { VerticalOptions = LayoutOptions.StartAndExpand };
+
+			layout.Children.Add(view);
+			var region = new Rectangle(Region_X, Region_Y, Region_Width, Region_Height);
+
+			Layout.LayoutChildIntoBoundingRegion(view, region);
+
+			var target = view.Bounds;
+			var thickness = margin * 2;
+
+			Assume.That(view.VerticalOptions.Alignment == LayoutAlignment.Start,
+					"view.VerticalOptions.Alignment should be Start");
+			Assume.That(view.VerticalOptions.Alignment.ToDouble() == 0,
+					"view.VerticalOptions.Alignment.ToDouble() should be 0");
+			Assume.That(view.HorizontalOptions.Alignment == LayoutAlignment.Fill,
+					"view.HorizontalOptions.Alignment should be Fill");
+
+			Assert.AreEqual(Expected_X_Fill_RTL_Plus_Margin(margin), target.X, "X");
+			Assert.AreEqual(Expected_Y_Fill_Plus_Margin(margin), target.Y, "Y");
+			Assert.AreEqual(Expected_Width_Fill_Less_Thickness(thickness), target.Width, "Width");
+			Assert.AreEqual(Expected_Height_Start_End, target.Height, "Height");
+		}
+
+		int Expected_Height_Fill_Less_Thickness(int thickness) => Region_Height - thickness;
+
+		int Expected_Width_Fill_Less_Thickness(int thickness) => Region_Width - thickness;
+
+		int Expected_X_Center_RTL_Plus_Margin(int margin) => Expected_Empty_Region_Width / 2 + Expected_X_Fill_RTL_Plus_Margin(margin);
+
+		int Expected_X_End_Less_Margin(int margin) => Expected_Empty_Region_Width + Region_X - margin;
+
+		int Expected_X_End_RTL_Plus_Margin(int margin) => Layout_Width - Region_Width - Region_X + margin;
+
+		int Expected_X_Fill_Plus_Margin(int margin) => Region_X + margin;
+
+		int Expected_X_Fill_RTL_Plus_Margin(int margin) => Layout_Width - Expected_Region_Right + margin;
+
+		int Expected_X_Start_Less_Margin(int margin) => Layout_Width - View_Size - Region_X - margin;
+
+		int Expected_Y_End_Less_Margin(int margin) => Expected_Empty_Region_Height + Region_Y - margin;
+
+		int Expected_Y_Fill_Plus_Margin(int margin) => Region_Y + margin;
+
+		class MockView : View
+		{
+			public MockView(int margin)
+			{
+				Margin = new Thickness(margin);
+				WidthRequest = View_Size;
+				HeightRequest = View_Size;
+			}
+		}
+	}
+}
\ No newline at end of file
diff --git a/Xamarin.Forms.Core.UnitTests/Xamarin.Forms.Core.UnitTests.csproj b/Xamarin.Forms.Core.UnitTests/Xamarin.Forms.Core.UnitTests.csproj
index 8cafd83edf1..c7c6b0b3c97 100644
--- a/Xamarin.Forms.Core.UnitTests/Xamarin.Forms.Core.UnitTests.csproj
+++ b/Xamarin.Forms.Core.UnitTests/Xamarin.Forms.Core.UnitTests.csproj
@@ -71,6 +71,9 @@
     <Compile Include="ColorUnitTests.cs" />
     <Compile Include="CommandSourceTests.cs" />
     <Compile Include="CommandTests.cs" />
+    <Compile Include="EffectiveFlowDirectionExtensions.cs" />
+    <Compile Include="FlowDirectionTests.cs" />
+    <Compile Include="LayoutChildIntoBoundingRegionTests.cs" />
     <Compile Include="MenuUnitTests.cs" />
     <Compile Include="TemplatedViewUnitTests.cs" />
     <Compile Include="TemplatedPageUnitTests.cs" />
@@ -208,4 +211,4 @@
       <LogicalName>Images/crimson.jpg</LogicalName>
     </EmbeddedResource>
   </ItemGroup>
-</Project>
+</Project>
\ No newline at end of file
diff --git a/Xamarin.Forms.Core/BindableObject.cs b/Xamarin.Forms.Core/BindableObject.cs
index 1df88b7d80d..9a774110aca 100644
--- a/Xamarin.Forms.Core/BindableObject.cs
+++ b/Xamarin.Forms.Core/BindableObject.cs
@@ -593,8 +593,7 @@ void SetValueActual(BindableProperty property, BindablePropertyContext context,
 
 				OnPropertyChanged(property.PropertyName);
 
-				if (property.PropertyChanged != null)
-					property.PropertyChanged(this, original, value);
+				property.PropertyChanged?.Invoke(this, original, value);
 			}
 		}
 
@@ -661,4 +660,4 @@ public enum SetValueFlags
 			RaiseOnEqual = 1 << 3
 		}
 	}
-}
\ No newline at end of file
+}
diff --git a/Xamarin.Forms.Core/Cells/Cell.cs b/Xamarin.Forms.Core/Cells/Cell.cs
index 6e088219d50..59d7e157846 100644
--- a/Xamarin.Forms.Core/Cells/Cell.cs
+++ b/Xamarin.Forms.Core/Cells/Cell.cs
@@ -4,10 +4,11 @@
 using System.Collections.Specialized;
 using System.ComponentModel;
 using System.Threading.Tasks;
+using Xamarin.Forms.Internals;
 
 namespace Xamarin.Forms
 {
-	public abstract class Cell : Element, ICellController
+	public abstract class Cell : Element, ICellController, IFlowDirectionController
 	{
 		public const int DefaultCellHeight = 40;
 		public static readonly BindableProperty IsEnabledProperty = BindableProperty.Create("IsEnabled", typeof(bool), typeof(Cell), true, propertyChanged: OnIsEnabledPropertyChanged);
@@ -18,6 +19,25 @@ public abstract class Cell : Element, ICellController
 
 		bool _nextCallToForceUpdateSizeQueued;
 
+		EffectiveFlowDirection _effectiveFlowDirection = default(EffectiveFlowDirection);
+		EffectiveFlowDirection IFlowDirectionController.EffectiveFlowDirection
+		{
+			get { return _effectiveFlowDirection; }
+			set
+			{
+				if (value == _effectiveFlowDirection)
+					return;
+
+				_effectiveFlowDirection = value;
+
+				var ve = (Parent as VisualElement);
+				ve?.InvalidateMeasureInternal(InvalidationTrigger.Undefined);
+				OnPropertyChanged(VisualElement.FlowDirectionProperty.PropertyName);
+			}
+		}
+
+		IFlowDirectionController FlowController => this;
+
 		public IList<MenuItem> ContextActions
 		{
 			get
@@ -75,6 +95,8 @@ public double RenderHeight
 			}
 		}
 
+		double IFlowDirectionController.Width => (Parent as VisualElement)?.Width ?? 0;
+
 		public event EventHandler Appearing;
 
 		public event EventHandler Disappearing;
@@ -136,6 +158,8 @@ protected override void OnParentSet()
 			}
 
 			base.OnParentSet();
+
+			FlowController.NotifyFlowDirectionChanged();
 		}
 
 		protected override void OnPropertyChanging(string propertyName = null)
@@ -147,6 +171,8 @@ protected override void OnPropertyChanging(string propertyName = null)
 					RealParent.PropertyChanged -= OnParentPropertyChanged;
 					RealParent.PropertyChanging -= OnParentPropertyChanging;
 				}
+
+				FlowController.NotifyFlowDirectionChanged();
 			}
 
 			base.OnPropertyChanging(propertyName);
@@ -172,6 +198,19 @@ public void SendDisappearing()
 				container.SendCellDisappearing(this);
 		}
 
+		void IFlowDirectionController.NotifyFlowDirectionChanged()
+		{
+			SetFlowDirectionFromParent(this);
+
+			foreach (var element in LogicalChildren)
+			{
+				var view = element as IFlowDirectionController;
+				if (view == null)
+					continue;
+				view.NotifyFlowDirectionChanged();
+			}
+		}
+
 		void OnContextActionsChanged(object sender, NotifyCollectionChangedEventArgs e)
 		{
 			for (var i = 0; i < _contextActions.Count; i++)
@@ -202,6 +241,8 @@ void OnParentPropertyChanged(object sender, PropertyChangedEventArgs e)
 			// its uncommon enough that we don't want to take the penalty of N GetValue calls to verify.
 			if (e.PropertyName == "RowHeight")
 				OnPropertyChanged("RenderHeight");
+			else if (e.PropertyName == VisualElement.FlowDirectionProperty.PropertyName)
+				FlowController.NotifyFlowDirectionChanged();
 		}
 
 		void OnParentPropertyChanging(object sender, PropertyChangingEventArgs e)
diff --git a/Xamarin.Forms.Core/Device.cs b/Xamarin.Forms.Core/Device.cs
index f2e614d0ba3..0a3f3bbf64e 100644
--- a/Xamarin.Forms.Core/Device.cs
+++ b/Xamarin.Forms.Core/Device.cs
@@ -27,6 +27,7 @@ public static class Device
 		public static void SetIdiom(TargetIdiom value) => Idiom = value;
 		public static TargetIdiom Idiom { get; internal set; }
 
+		//TODO: Why are there two of these? This is never used...?
 		[EditorBrowsable(EditorBrowsableState.Never)]
 		public static void SetTargetIdiom(TargetIdiom value) => Idiom = value;
 
@@ -65,6 +66,10 @@ public static DeviceInfo Info
 			set { info = value; }
 		}
 
+		[EditorBrowsable(EditorBrowsableState.Never)]
+		public static void SetFlowDirection(FlowDirection value) => FlowDirection = value;
+		public static FlowDirection FlowDirection { get; internal set; }
+
 		[EditorBrowsable(EditorBrowsableState.Never)]
 		public static bool IsInvokeRequired
 		{
diff --git a/Xamarin.Forms.Core/EffectiveFlowDirection.cs b/Xamarin.Forms.Core/EffectiveFlowDirection.cs
new file mode 100644
index 00000000000..d492c171ea2
--- /dev/null
+++ b/Xamarin.Forms.Core/EffectiveFlowDirection.cs
@@ -0,0 +1,11 @@
+using System;
+
+namespace Xamarin.Forms
+{
+	[Flags]
+	public enum EffectiveFlowDirection
+	{
+		RightToLeft = 1 << 0,
+		Explicit = 1 << 1,
+	}
+}
\ No newline at end of file
diff --git a/Xamarin.Forms.Core/EffectiveFlowDirectionExtensions.cs b/Xamarin.Forms.Core/EffectiveFlowDirectionExtensions.cs
new file mode 100644
index 00000000000..a94eb0924d6
--- /dev/null
+++ b/Xamarin.Forms.Core/EffectiveFlowDirectionExtensions.cs
@@ -0,0 +1,72 @@
+using System;
+using System.ComponentModel;
+
+namespace Xamarin.Forms
+{
+	[EditorBrowsable(EditorBrowsableState.Never)]
+	public static class EffectiveFlowDirectionExtensions
+	{
+		internal static EffectiveFlowDirection ToEffectiveFlowDirection(this FlowDirection self, bool isExplicit = false)
+		{
+			switch (self)
+			{
+				case FlowDirection.MatchParent:
+					return default(EffectiveFlowDirection);
+
+
+				case FlowDirection.LeftToRight:
+					if (isExplicit)
+					{
+						return EffectiveFlowDirection.Explicit;
+					}
+					else
+					{
+						return default(EffectiveFlowDirection);
+					}
+
+				case FlowDirection.RightToLeft:
+					if (isExplicit)
+					{
+						return EffectiveFlowDirection.RightToLeft | EffectiveFlowDirection.Explicit;
+					}
+					else
+					{
+						return EffectiveFlowDirection.RightToLeft;
+					}
+
+				default:
+					throw new InvalidOperationException($"Cannot convert {self} to {nameof(EffectiveFlowDirection)}.");
+			}
+		}
+
+		internal static FlowDirection ToFlowDirection(this EffectiveFlowDirection self)
+		{
+			if (self.IsLeftToRight())
+				return FlowDirection.LeftToRight;
+			else
+				return FlowDirection.RightToLeft;
+
+			throw new InvalidOperationException($"Cannot convert {self} to {nameof(FlowDirection)}.");
+		}
+
+		public static bool IsRightToLeft(this EffectiveFlowDirection self)
+		{
+			return (self & EffectiveFlowDirection.RightToLeft) == EffectiveFlowDirection.RightToLeft;
+		}
+
+		public static bool IsLeftToRight(this EffectiveFlowDirection self)
+		{
+			return (self & EffectiveFlowDirection.RightToLeft) != EffectiveFlowDirection.RightToLeft;
+		}
+
+		public static bool IsImplicit(this EffectiveFlowDirection self)
+		{
+			return (self & EffectiveFlowDirection.Explicit) != EffectiveFlowDirection.Explicit;
+		}
+
+		public static bool IsExplicit(this EffectiveFlowDirection self)
+		{
+			return (self & EffectiveFlowDirection.Explicit) == EffectiveFlowDirection.Explicit;
+		}
+	}
+}
\ No newline at end of file
diff --git a/Xamarin.Forms.Core/Element.cs b/Xamarin.Forms.Core/Element.cs
index 1f8725f2631..d8fdcdf60ce 100644
--- a/Xamarin.Forms.Core/Element.cs
+++ b/Xamarin.Forms.Core/Element.cs
@@ -503,6 +503,27 @@ internal override void OnSetDynamicResource(BindableProperty property, string ke
 
 		internal event EventHandler ParentSet;
 
+		internal static void SetFlowDirectionFromParent(Element child)
+		{
+			IFlowDirectionController controller = child as IFlowDirectionController;
+			if (controller == null)
+				return;
+
+			if (controller.EffectiveFlowDirection.IsImplicit())
+			{
+				var parentView = child.Parent as IFlowDirectionController;
+				if (parentView == null)
+					return;
+
+				var flowDirection = parentView.EffectiveFlowDirection.ToFlowDirection();
+
+				if (flowDirection != controller.EffectiveFlowDirection.ToFlowDirection())
+				{
+					controller.EffectiveFlowDirection = flowDirection.ToEffectiveFlowDirection();
+				}
+			}
+		}
+
 		[EditorBrowsable(EditorBrowsableState.Never)]
 		public event EventHandler PlatformSet;
 
diff --git a/Xamarin.Forms.Core/FlowDirection.cs b/Xamarin.Forms.Core/FlowDirection.cs
new file mode 100644
index 00000000000..44ccd48e4b3
--- /dev/null
+++ b/Xamarin.Forms.Core/FlowDirection.cs
@@ -0,0 +1,9 @@
+namespace Xamarin.Forms
+{
+	public enum FlowDirection
+	{
+		MatchParent = 0,
+		LeftToRight = 1,
+		RightToLeft = 2,
+	}
+}
\ No newline at end of file
diff --git a/Xamarin.Forms.Core/IFlowDirectionController.cs b/Xamarin.Forms.Core/IFlowDirectionController.cs
new file mode 100644
index 00000000000..20b1b96a993
--- /dev/null
+++ b/Xamarin.Forms.Core/IFlowDirectionController.cs
@@ -0,0 +1,11 @@
+namespace Xamarin.Forms
+{
+	internal interface IFlowDirectionController
+	{
+		EffectiveFlowDirection EffectiveFlowDirection { get; set; }
+
+		double Width { get; }
+
+		void NotifyFlowDirectionChanged();
+	}
+}
\ No newline at end of file
diff --git a/Xamarin.Forms.Core/IVisualElementController.cs b/Xamarin.Forms.Core/IVisualElementController.cs
index b1450371ebc..c398138ace3 100644
--- a/Xamarin.Forms.Core/IVisualElementController.cs
+++ b/Xamarin.Forms.Core/IVisualElementController.cs
@@ -10,6 +10,7 @@ public interface IVisualElementController : IElementController
 		void InvalidateMeasure(InvalidationTrigger trigger);
 		bool Batched { get; }
 		bool DisableLayout { get; set; }
+		EffectiveFlowDirection EffectiveFlowDirection { get; }
 		bool IsInNativeLayout { get; set; }
 		bool IsNativeStateConsistent { get; set; }
 		bool IsPlatformEnabled { get; set; }
diff --git a/Xamarin.Forms.Core/Layout.cs b/Xamarin.Forms.Core/Layout.cs
index 537fd97119c..cb8d671fd6d 100644
--- a/Xamarin.Forms.Core/Layout.cs
+++ b/Xamarin.Forms.Core/Layout.cs
@@ -55,7 +55,8 @@ public abstract class Layout : View, ILayout, ILayoutController
 		public static readonly BindableProperty IsClippedToBoundsProperty = BindableProperty.Create("IsClippedToBounds", typeof(bool), typeof(Layout), false);
 
 		public static readonly BindableProperty PaddingProperty = BindableProperty.Create("Padding", typeof(Thickness), typeof(Layout), default(Thickness),
-									propertyChanged: (bindable, old, newValue) => {
+									propertyChanged: (bindable, old, newValue) =>
+									{
 										var layout = (Layout)bindable;
 										layout.UpdateChildrenLayout();
 									}, defaultValueCreator: (bindable) => ((Layout)bindable).CreateDefaultPadding());
@@ -125,6 +126,11 @@ public sealed override SizeRequest GetSizeRequest(double widthConstraint, double
 
 		public static void LayoutChildIntoBoundingRegion(VisualElement child, Rectangle region)
 		{
+			var parent = child.Parent as IFlowDirectionController;
+			bool isRightToLeft = false;
+			if (parent != null && (isRightToLeft = parent.EffectiveFlowDirection.IsRightToLeft()))
+				region = new Rectangle(parent.Width - region.Right, region.Y, region.Width, region.Height);
+
 			var view = child as View;
 			if (view == null)
 			{
@@ -137,7 +143,10 @@ public static void LayoutChildIntoBoundingRegion(VisualElement child, Rectangle
 			{
 				SizeRequest request = child.Measure(region.Width, region.Height, MeasureFlags.IncludeMargins);
 				double diff = Math.Max(0, region.Width - request.Request.Width);
-				region.X += (int)(diff * horizontalOptions.Alignment.ToDouble());
+				double horizontalAlign = horizontalOptions.Alignment.ToDouble();
+				if (isRightToLeft)
+					horizontalAlign = 1 - horizontalAlign;
+				region.X += (int)(diff * horizontalAlign);
 				region.Width -= diff;
 			}
 
@@ -260,23 +269,33 @@ protected void UpdateChildrenLayout()
 
 		internal static void LayoutChildIntoBoundingRegion(View child, Rectangle region, SizeRequest childSizeRequest)
 		{
+			var parent = child.Parent as IFlowDirectionController;
+			bool isRightToLeft = false;
+			if (parent != null && (isRightToLeft = parent.EffectiveFlowDirection.IsRightToLeft()))
+				region = new Rectangle(parent.Width - region.Right, region.Y, region.Width, region.Height);
+
 			if (region.Size != childSizeRequest.Request)
 			{
 				bool canUseAlreadyDoneRequest = region.Width >= childSizeRequest.Request.Width && region.Height >= childSizeRequest.Request.Height;
 
-				if (child.HorizontalOptions.Alignment != LayoutAlignment.Fill)
+				LayoutOptions horizontalOptions = child.HorizontalOptions;
+				if (horizontalOptions.Alignment != LayoutAlignment.Fill)
 				{
 					SizeRequest request = canUseAlreadyDoneRequest ? childSizeRequest : child.Measure(region.Width, region.Height, MeasureFlags.IncludeMargins);
 					double diff = Math.Max(0, region.Width - request.Request.Width);
-					region.X += (int)(diff * child.HorizontalOptions.Alignment.ToDouble());
+					double horizontalAlign = horizontalOptions.Alignment.ToDouble();
+					if (isRightToLeft)
+						horizontalAlign = 1 - horizontalAlign;
+					region.X += (int)(diff * horizontalAlign);
 					region.Width -= diff;
 				}
 
-				if (child.VerticalOptions.Alignment != LayoutAlignment.Fill)
+				LayoutOptions verticalOptions = child.VerticalOptions;
+				if (verticalOptions.Alignment != LayoutAlignment.Fill)
 				{
 					SizeRequest request = canUseAlreadyDoneRequest ? childSizeRequest : child.Measure(region.Width, region.Height, MeasureFlags.IncludeMargins);
 					double diff = Math.Max(0, region.Height - request.Request.Height);
-					region.Y += (int)(diff * child.VerticalOptions.Alignment.ToDouble());
+					region.Y += (int)(diff * verticalOptions.Alignment.ToDouble());
 					region.Height -= diff;
 				}
 			}
diff --git a/Xamarin.Forms.Core/VisualElement.cs b/Xamarin.Forms.Core/VisualElement.cs
index 520b06b1787..a6acc43b804 100644
--- a/Xamarin.Forms.Core/VisualElement.cs
+++ b/Xamarin.Forms.Core/VisualElement.cs
@@ -5,7 +5,7 @@
 
 namespace Xamarin.Forms
 {
-	public partial class VisualElement : Element, IAnimatable, IVisualElementController, IResourcesProvider
+	public partial class VisualElement : Element, IAnimatable, IVisualElementController, IResourcesProvider, IFlowDirectionController
 	{
 		internal static readonly BindablePropertyKey NavigationPropertyKey = BindableProperty.CreateReadOnly("Navigation", typeof(INavigation), typeof(VisualElement), default(INavigation));
 
@@ -93,6 +93,33 @@ public partial class VisualElement : Element, IAnimatable, IVisualElementControl
 
 		public static readonly BindableProperty IsFocusedProperty = IsFocusedPropertyKey.BindableProperty;
 
+		public static readonly BindableProperty FlowDirectionProperty = BindableProperty.Create(nameof(FlowDirection), typeof(FlowDirection), typeof(VisualElement), FlowDirection.MatchParent, propertyChanged: FlowDirectionChanged);
+
+		IFlowDirectionController FlowController => this;
+
+		public FlowDirection FlowDirection
+		{
+			get { return (FlowDirection)GetValue(FlowDirectionProperty); }
+			set { SetValue(FlowDirectionProperty, value); }
+		}
+
+		EffectiveFlowDirection _effectiveFlowDirection = default(EffectiveFlowDirection);
+		EffectiveFlowDirection IFlowDirectionController.EffectiveFlowDirection
+		{
+			get { return _effectiveFlowDirection; }
+			set
+			{
+				if (value == _effectiveFlowDirection)
+					return;
+
+				_effectiveFlowDirection = value;
+				InvalidateMeasureInternal(InvalidationTrigger.Undefined);
+				OnPropertyChanged(FlowDirectionProperty.PropertyName);
+			}
+		}
+
+		EffectiveFlowDirection IVisualElementController.EffectiveFlowDirection => FlowController.EffectiveFlowDirection;
+
 		readonly Dictionary<Size, SizeRequest> _measureCache = new Dictionary<Size, SizeRequest>();
 
 		readonly MergedStyle _mergedStyle;
@@ -250,7 +277,7 @@ public Style Style
 			set { SetValue(StyleProperty, value); }
 		}
 
-		[TypeConverter (typeof(ListStringTypeConverter))]
+		[TypeConverter(typeof(ListStringTypeConverter))]
 		public IList<string> StyleClass
 		{
 			get { return _mergedStyle.StyleClass; }
@@ -537,9 +564,6 @@ public SizeRequest Measure(double widthConstraint, double heightConstraint, Meas
 
 			if (includeMargins)
 			{
-				
-				
-
 				if (!margin.IsDefault)
 				{
 					result.Minimum = new Size(result.Minimum.Width + margin.HorizontalThickness, result.Minimum.Height + margin.VerticalThickness);
@@ -616,6 +640,8 @@ protected override void OnParentSet()
 				NavigationProxy.Inner = null;
 			}
 #pragma warning restore 0618
+
+			FlowController.NotifyFlowDirectionChanged();
 		}
 
 		protected virtual void OnSizeAllocated(double width, double height)
@@ -738,6 +764,20 @@ void OnFocused()
 				focus(this, new FocusEventArgs(this, true));
 		}
 
+		static void FlowDirectionChanged(BindableObject bindable, object oldValue, object newValue)
+		{
+			var self = bindable as IFlowDirectionController;
+
+			if (self.EffectiveFlowDirection.IsExplicit() && oldValue == newValue)
+				return;
+
+			var newFlowDirection = (FlowDirection)newValue;
+
+			self.EffectiveFlowDirection = newFlowDirection.ToEffectiveFlowDirection(isExplicit: true);
+
+			self.NotifyFlowDirectionChanged();
+		}
+
 		static void OnIsFocusedPropertyChanged(BindableObject bindable, object oldvalue, object newvalue)
 		{
 			var element = bindable as VisualElement;
@@ -777,6 +817,19 @@ void OnUnfocus()
 				unFocus(this, new FocusEventArgs(this, false));
 		}
 
+		void IFlowDirectionController.NotifyFlowDirectionChanged()
+		{
+			SetFlowDirectionFromParent(this);
+
+			foreach (var element in LogicalChildren)
+			{
+				var view = element as IFlowDirectionController;
+				if (view == null)
+					continue;
+				view.NotifyFlowDirectionChanged();
+			}
+		}
+
 		void SetSize(double width, double height)
 		{
 			if (Width == width && Height == height)
diff --git a/Xamarin.Forms.Core/Xamarin.Forms.Core.csproj b/Xamarin.Forms.Core/Xamarin.Forms.Core.csproj
index fdf0b5e869d..e7547cabfdb 100644
--- a/Xamarin.Forms.Core/Xamarin.Forms.Core.csproj
+++ b/Xamarin.Forms.Core/Xamarin.Forms.Core.csproj
@@ -77,7 +77,9 @@
     <Compile Include="DataTemplateSelector.cs" />
     <Compile Include="DateChangedEventArgs.cs" />
     <Compile Include="DelegateLogListener.cs" />
+    <Compile Include="EffectiveFlowDirectionExtensions.cs" />
     <Compile Include="IEditorController.cs" />
+    <Compile Include="IFlowDirectionController.cs" />
     <Compile Include="IGridController.cs" />
     <Compile Include="IWebViewController.cs" />
     <Compile Include="INavigationMenuController.cs" />
@@ -110,6 +112,8 @@
     <Compile Include="IElementConfiguration.cs" />
     <Compile Include="IPlatformElementConfiguration.cs" />
     <Compile Include="PlatformConfigurationRegistry.cs" />
+    <Compile Include="EffectiveFlowDirection.cs" />
+    <Compile Include="FlowDirection.cs" />
     <Compile Include="IFontElement.cs" />
     <Compile Include="DependencyAttribute.cs" />
     <Compile Include="DependencyFetchTarget.cs" />
diff --git a/Xamarin.Forms.Platform.Android/AppCompat/MasterDetailPageRenderer.cs b/Xamarin.Forms.Platform.Android/AppCompat/MasterDetailPageRenderer.cs
index 2213bcac540..e3b09d7a75e 100644
--- a/Xamarin.Forms.Platform.Android/AppCompat/MasterDetailPageRenderer.cs
+++ b/Xamarin.Forms.Platform.Android/AppCompat/MasterDetailPageRenderer.cs
@@ -153,6 +153,8 @@ void IVisualElementRenderer.SetElement(VisualElement element)
 				UpdateMaster();
 				UpdateDetail();
 
+				UpdateFlowDirection();
+
 				((IMasterDetailPageController)newElement).BackButtonPressed += OnBackButtonPressed;
 				newElement.PropertyChanged += HandlePropertyChanged;
 				newElement.Appearing += MasterDetailPageAppearing;
@@ -310,6 +312,8 @@ void HandlePropertyChanged(object sender, PropertyChangedEventArgs e)
 				UpdateBackgroundImage(Element);
 			else if (e.PropertyName == VisualElement.BackgroundColorProperty.PropertyName)
 				UpdateBackgroundColor(Element);
+			else if (e.PropertyName == VisualElement.FlowDirectionProperty.PropertyName)
+				UpdateFlowDirection();
 		}
 
 		void MasterDetailPageAppearing(object sender, EventArgs e)
@@ -367,6 +371,11 @@ void UpdateDetail()
 			_detailLayout.ChildView = Element.Detail;
 		}
 
+		void UpdateFlowDirection()
+		{
+			this.UpdateFlowDirection(Element);
+		}
+
 		void UpdateIsPresented()
 		{
 			if (_isPresentingFromCore)
diff --git a/Xamarin.Forms.Platform.Android/Cells/BaseCellView.cs b/Xamarin.Forms.Platform.Android/Cells/BaseCellView.cs
index e5fc6e41907..67f33c0d8ec 100644
--- a/Xamarin.Forms.Platform.Android/Cells/BaseCellView.cs
+++ b/Xamarin.Forms.Platform.Android/Cells/BaseCellView.cs
@@ -11,6 +11,7 @@
 using AColorDraw = Android.Graphics.Drawables.ColorDrawable;
 using Xamarin.Forms.Internals;
 using Android.Support.V4.Widget;
+using Android.OS;
 
 namespace Xamarin.Forms.Platform.Android
 {
@@ -80,6 +81,12 @@ public BaseCellView(Context context, Cell cell) : base(context)
 
 			SetMinimumHeight((int)context.ToPixels(DefaultMinHeight));
 			_androidDefaultTextColor = Color.FromUint((uint)_mainText.CurrentTextColor);
+
+			if ((int)Build.VERSION.SdkInt > 16)
+			{
+				_mainText.TextAlignment = global::Android.Views.TextAlignment.ViewStart;
+				_detailText.TextAlignment = global::Android.Views.TextAlignment.ViewStart;
+			}
 		}
 
 		public AView AccessoryView { get; private set; }
diff --git a/Xamarin.Forms.Platform.Android/Cells/EntryCellRenderer.cs b/Xamarin.Forms.Platform.Android/Cells/EntryCellRenderer.cs
index dc65853117a..465b801359c 100644
--- a/Xamarin.Forms.Platform.Android/Cells/EntryCellRenderer.cs
+++ b/Xamarin.Forms.Platform.Android/Cells/EntryCellRenderer.cs
@@ -29,6 +29,7 @@ public class EntryCellRenderer : CellRenderer
 			UpdateText();
 			UpdateIsEnabled();
 			UpdateHeight();
+			UpdateFlowDirection();
 
 			_view.TextChanged = OnTextChanged;
 			_view.EditingCompleted = OnEditingCompleted;
@@ -56,6 +57,11 @@ protected override void OnCellPropertyChanged(object sender, PropertyChangedEven
 				UpdateIsEnabled();
 			else if (e.PropertyName == "RenderHeight")
 				UpdateHeight();
+			else if (e.PropertyName == VisualElement.FlowDirectionProperty.PropertyName)
+			{
+				UpdateFlowDirection();
+				UpdateHorizontalTextAlignment();
+			}
 		}
 
 		protected virtual NumberKeyListener GetDigitsKeyListener(InputTypes inputTypes)
@@ -86,7 +92,7 @@ void UpdateHeight()
 		void UpdateHorizontalTextAlignment()
 		{
 			var entryCell = (EntryCell)Cell;
-			_view.EditText.Gravity = entryCell.HorizontalTextAlignment.ToHorizontalGravityFlags();
+			_view.EditText.UpdateHorizontalAlignment(entryCell.HorizontalTextAlignment);
 		}
 
 		void UpdateIsEnabled()
@@ -117,6 +123,11 @@ void UpdateLabelColor()
 			_view.SetLabelTextColor(((EntryCell)Cell).LabelColor, global::Android.Resource.Color.PrimaryTextDark);
 		}
 
+		void UpdateFlowDirection()
+		{
+			_view.UpdateFlowDirection(ParentView);
+		}
+
 		void UpdatePlaceholder()
 		{
 			var entryCell = (EntryCell)Cell;
diff --git a/Xamarin.Forms.Platform.Android/Cells/ImageCellRenderer.cs b/Xamarin.Forms.Platform.Android/Cells/ImageCellRenderer.cs
index 62815ed6dd7..11ff2af1093 100644
--- a/Xamarin.Forms.Platform.Android/Cells/ImageCellRenderer.cs
+++ b/Xamarin.Forms.Platform.Android/Cells/ImageCellRenderer.cs
@@ -11,6 +11,7 @@ public class ImageCellRenderer : TextCellRenderer
 			var result = (BaseCellView)base.GetCellCore(item, convertView, parent, context);
 
 			UpdateImage();
+			UpdateFlowDirection();
 
 			return result;
 		}
@@ -20,6 +21,8 @@ protected override void OnCellPropertyChanged(object sender, PropertyChangedEven
 			base.OnCellPropertyChanged(sender, args);
 			if (args.PropertyName == ImageCell.ImageSourceProperty.PropertyName)
 				UpdateImage();
+			else if (args.PropertyName == VisualElement.FlowDirectionProperty.PropertyName)
+				UpdateFlowDirection();
 		}
 
 		void UpdateImage()
@@ -33,5 +36,10 @@ void UpdateImage()
 			else
 				View.SetImageVisible(false);
 		}
+
+		void UpdateFlowDirection()
+		{
+			View.UpdateFlowDirection(ParentView);
+		}
 	}
 }
\ No newline at end of file
diff --git a/Xamarin.Forms.Platform.Android/Cells/SwitchCellRenderer.cs b/Xamarin.Forms.Platform.Android/Cells/SwitchCellRenderer.cs
index f2ea5cc3569..fe01b56d8f1 100644
--- a/Xamarin.Forms.Platform.Android/Cells/SwitchCellRenderer.cs
+++ b/Xamarin.Forms.Platform.Android/Cells/SwitchCellRenderer.cs
@@ -8,7 +8,6 @@ namespace Xamarin.Forms.Platform.Android
 {
 	public class SwitchCellRenderer : CellRenderer
 	{
-		const double DefaultHeight = 30;
 		SwitchCellView _view;
 
 		protected override AView GetCellCore(Cell item, AView convertView, ViewGroup parent, Context context)
@@ -24,6 +23,7 @@ protected override AView GetCellCore(Cell item, AView convertView, ViewGroup par
 			UpdateChecked();
 			UpdateHeight();
 			UpdateIsEnabled(_view, cell);
+			UpdateFlowDirection();
 
 			return _view;
 		}
@@ -38,6 +38,8 @@ protected override void OnCellPropertyChanged(object sender, PropertyChangedEven
 				UpdateHeight();
 			else if (args.PropertyName == Cell.IsEnabledProperty.PropertyName)
 				UpdateIsEnabled(_view, (SwitchCell)sender);
+			else if (args.PropertyName == VisualElement.FlowDirectionProperty.PropertyName)
+				UpdateFlowDirection();
 		}
 
 		void UpdateChecked()
@@ -53,6 +55,11 @@ void UpdateIsEnabled(SwitchCellView cell, SwitchCell switchCell)
 				aSwitch.Enabled = switchCell.IsEnabled;
 		}
 
+		void UpdateFlowDirection()
+		{
+			_view.UpdateFlowDirection(ParentView);
+		}
+
 		void UpdateHeight()
 		{
 			_view.SetRenderHeight(Cell.RenderHeight);
diff --git a/Xamarin.Forms.Platform.Android/Cells/TextCellRenderer.cs b/Xamarin.Forms.Platform.Android/Cells/TextCellRenderer.cs
index b678ee1c155..9e9ecacd68e 100644
--- a/Xamarin.Forms.Platform.Android/Cells/TextCellRenderer.cs
+++ b/Xamarin.Forms.Platform.Android/Cells/TextCellRenderer.cs
@@ -1,9 +1,8 @@
 using System.ComponentModel;
 using Android.Content;
 using Android.Views;
-using AView = Android.Views.View;
-using AColor = Android.Graphics.Color;
 using Xamarin.Forms.Internals;
+using AView = Android.Views.View;
 
 namespace Xamarin.Forms.Platform.Android
 {
@@ -20,6 +19,7 @@ protected override AView GetCellCore(Cell item, AView convertView, ViewGroup par
 			UpdateDetailText();
 			UpdateHeight();
 			UpdateIsEnabled();
+			UpdateFlowDirection();
 			View.SetImageVisible(false);
 
 			return View;
@@ -35,6 +35,8 @@ protected override void OnCellPropertyChanged(object sender, PropertyChangedEven
 				UpdateIsEnabled();
 			else if (args.PropertyName == "RenderHeight")
 				UpdateHeight();
+			else if (args.PropertyName == VisualElement.FlowDirectionProperty.PropertyName)
+				UpdateFlowDirection();
 		}
 
 		void UpdateDetailText()
@@ -55,6 +57,11 @@ void UpdateIsEnabled()
 			View.SetIsEnabled(cell.IsEnabled);
 		}
 
+		void UpdateFlowDirection()
+		{
+			View.UpdateFlowDirection(ParentView);
+		}
+
 		void UpdateMainText()
 		{
 			var cell = (TextCell)Cell;
diff --git a/Xamarin.Forms.Platform.Android/Extensions/FlowDirectionExtensions.cs b/Xamarin.Forms.Platform.Android/Extensions/FlowDirectionExtensions.cs
new file mode 100644
index 00000000000..c552625b748
--- /dev/null
+++ b/Xamarin.Forms.Platform.Android/Extensions/FlowDirectionExtensions.cs
@@ -0,0 +1,44 @@
+using Android.OS;
+using Android.Widget;
+using Xamarin.Forms.Internals;
+using ALayoutDirection = Android.Views.LayoutDirection;
+using AView = Android.Views.View;
+
+
+namespace Xamarin.Forms.Platform.Android
+{
+	internal static class FlowDirectionExtensions
+	{
+		internal static FlowDirection ToFlowDirection(this ALayoutDirection direction)
+		{
+			switch (direction)
+			{
+				case ALayoutDirection.Ltr:
+					return FlowDirection.LeftToRight;
+				case ALayoutDirection.Rtl:
+					return FlowDirection.RightToLeft;
+				default:
+					return FlowDirection.MatchParent;
+			}
+		}
+
+		internal static void UpdateFlowDirection(this AView view, IVisualElementController controller)
+		{
+			if (view == null || controller == null || (int)Build.VERSION.SdkInt < 17)
+				return;
+
+			if (controller.EffectiveFlowDirection.IsRightToLeft())
+				view.LayoutDirection = ALayoutDirection.Rtl;
+			else if (controller.EffectiveFlowDirection.IsLeftToRight())
+				view.LayoutDirection = ALayoutDirection.Ltr;
+		}
+
+		internal static void UpdateHorizontalAlignment(this EditText view, TextAlignment alignment)
+		{
+			if ((int)Build.VERSION.SdkInt < 17)
+				view.Gravity = alignment.ToHorizontalGravityFlags();
+			else
+				view.TextAlignment = alignment.ToTextAlignment();
+		}
+	}
+}
\ No newline at end of file
diff --git a/Xamarin.Forms.Platform.Android/FastRenderers/VisualElementRenderer.cs b/Xamarin.Forms.Platform.Android/FastRenderers/VisualElementRenderer.cs
index c696768898c..f90c572caf4 100644
--- a/Xamarin.Forms.Platform.Android/FastRenderers/VisualElementRenderer.cs
+++ b/Xamarin.Forms.Platform.Android/FastRenderers/VisualElementRenderer.cs
@@ -3,7 +3,6 @@
 using Android.Views;
 using Xamarin.Forms.Internals;
 using AView = Android.Views.View;
-using Object = Java.Lang.Object;
 
 namespace Xamarin.Forms.Platform.Android.FastRenderers
 {
@@ -14,7 +13,7 @@ internal sealed class VisualElementRenderer : IDisposable, IEffectControlProvide
 		
 		IVisualElementRenderer _renderer;
 		readonly GestureManager _gestureManager;
-		readonly AutomationPropertiesProvider _automatiomPropertiesProvider;
+		readonly AutomationPropertiesProvider _automationPropertiesProvider;
 		readonly EffectControlProvider _effectControlProvider;
 
 		public VisualElementRenderer(IVisualElementRenderer renderer)
@@ -23,13 +22,13 @@ public VisualElementRenderer(IVisualElementRenderer renderer)
 			_renderer.ElementPropertyChanged += OnElementPropertyChanged;
 			_renderer.ElementChanged += OnElementChanged;
 			_gestureManager = new GestureManager(_renderer);
-			_automatiomPropertiesProvider = new AutomationPropertiesProvider(_renderer);
+			_automationPropertiesProvider = new AutomationPropertiesProvider(_renderer);
 
 			_effectControlProvider = new EffectControlProvider(_renderer?.View);
 		}
 
 		VisualElement Element => _renderer?.Element;
-		
+
 		AView Control => _renderer?.View;
 
 		void IEffectControlProvider.RegisterEffect(Effect effect)
@@ -45,7 +44,15 @@ public void UpdateBackgroundColor(Color? color = null)
 			Control.SetBackgroundColor((color ?? Element.BackgroundColor).ToAndroid());
 		}
 
-	    public bool OnTouchEvent(MotionEvent e)
+		void UpdateFlowDirection()
+		{
+			if (_disposed)
+				return;
+
+			Control.UpdateFlowDirection(Element);
+		}
+
+		public bool OnTouchEvent(MotionEvent e)
 	    {
 	        return _gestureManager.OnTouchEvent(e);
 	    }
@@ -66,7 +73,7 @@ void Dispose(bool disposing)
 			if (disposing)
 			{
 				_gestureManager?.Dispose();
-				_automatiomPropertiesProvider?.Dispose();
+				_automationPropertiesProvider?.Dispose();
 
 				if (_renderer != null)
 				{
@@ -88,6 +95,7 @@ void OnElementChanged(object sender, VisualElementChangedEventArgs e)
 			{
 				e.NewElement.PropertyChanged += OnElementPropertyChanged;
 				UpdateBackgroundColor();
+				UpdateFlowDirection();
 			}
 
 			EffectUtilities.RegisterEffectControlProvider(this, e.OldElement, e.NewElement);
@@ -97,6 +105,8 @@ void OnElementPropertyChanged(object sender, PropertyChangedEventArgs e)
 		{
 			if (e.PropertyName == VisualElement.BackgroundColorProperty.PropertyName)
 				UpdateBackgroundColor();
+			else if (e.PropertyName == VisualElement.FlowDirectionProperty.PropertyName)
+				UpdateFlowDirection();
 		}
 	}
 }
diff --git a/Xamarin.Forms.Platform.Android/Forms.cs b/Xamarin.Forms.Platform.Android/Forms.cs
index 3f189110efa..893c95bc887 100644
--- a/Xamarin.Forms.Platform.Android/Forms.cs
+++ b/Xamarin.Forms.Platform.Android/Forms.cs
@@ -20,6 +20,7 @@
 using Xamarin.Forms.Platform.Android;
 using Resource = Android.Resource;
 using Trace = System.Diagnostics.Trace;
+using ALayoutDirection = Android.Views.LayoutDirection;
 
 namespace Xamarin.Forms
 {
@@ -69,7 +70,7 @@ public static void Init(Context activity, Bundle bundle, Assembly resourceAssemb
 			+ "Please use SetTitleBarVisibility(Activity, AndroidTitleBarVisibility) instead.")]
 		public static void SetTitleBarVisibility(AndroidTitleBarVisibility visibility)
 		{
-			if((Activity)Context == null)
+			if ((Activity)Context == null)
 				throw new NullReferenceException("Must be called after Xamarin.Forms.Forms.Init() method");
 
 			if (visibility == AndroidTitleBarVisibility.Never)
@@ -138,7 +139,7 @@ static void SetupInit(Context activity, Assembly resourceAssembly)
 			// We want this to be updated when we have a new activity (e.g. on a configuration change)
 			// because AndroidPlatformServices needs a current activity to launch URIs from
 			Device.PlatformServices = new AndroidPlatformServices(activity);
-			
+
 			// use field and not property to avoid exception in getter
 			if (Device.info != null)
 			{
@@ -165,6 +166,7 @@ static void SetupInit(Context activity, Assembly resourceAssembly)
 			// This could change as a result of a config change, so we need to check it every time
 			int minWidthDp = activity.Resources.Configuration.SmallestScreenWidthDp;
 			Device.SetIdiom(minWidthDp >= TabletCrossover ? TargetIdiom.Tablet : TargetIdiom.Phone);
+			Device.SetFlowDirection(activity.Resources.Configuration.LayoutDirection.ToFlowDirection());
 
 			if (ExpressionSearch.Default == null)
 				ExpressionSearch.Default = new AndroidExpressionSearch();
@@ -198,11 +200,11 @@ static Color GetAccentColor(Context context)
 			Color rc;
 			using (var value = new TypedValue())
 			{
-				if (context.Theme.ResolveAttribute(global::Android.Resource.Attribute.ColorAccent, value, true) && Forms.IsLollipopOrNewer)	// Android 5.0+
+				if (context.Theme.ResolveAttribute(global::Android.Resource.Attribute.ColorAccent, value, true) && Forms.IsLollipopOrNewer) // Android 5.0+
 				{
 					rc = Color.FromUint((uint)value.Data);
 				}
-				else if(context.Theme.ResolveAttribute(context.Resources.GetIdentifier("colorAccent", "attr", context.PackageName), value, true))	// < Android 5.0
+				else if (context.Theme.ResolveAttribute(context.Resources.GetIdentifier("colorAccent", "attr", context.PackageName), value, true))  // < Android 5.0
 				{
 					rc = Color.FromUint((uint)value.Data);
 				}
@@ -475,7 +477,7 @@ public void OpenUriAction(Uri uri)
 			{
 				global::Android.Net.Uri aUri = global::Android.Net.Uri.Parse(uri.ToString());
 				var intent = new Intent(Intent.ActionView, aUri);
-				
+
 				// This seems to work fine even if the context has been destroyed (while another activity is in the
 				// foreground). If we run into a situation where that's not the case, we'll have to do some work to
 				// make sure this uses the active activity when launching the Intent
diff --git a/Xamarin.Forms.Platform.Android/Renderers/AlignmentExtensions.cs b/Xamarin.Forms.Platform.Android/Renderers/AlignmentExtensions.cs
index dd05f166d29..5d2bd571896 100644
--- a/Xamarin.Forms.Platform.Android/Renderers/AlignmentExtensions.cs
+++ b/Xamarin.Forms.Platform.Android/Renderers/AlignmentExtensions.cs
@@ -1,9 +1,23 @@
 using Android.Views;
+using ATextAlignment = Android.Views.TextAlignment;
 
 namespace Xamarin.Forms.Platform.Android
 {
 	internal static class AlignmentExtensions
 	{
+		internal static ATextAlignment ToTextAlignment(this TextAlignment alignment)
+		{
+			switch (alignment)
+			{
+				case TextAlignment.Center:
+					return ATextAlignment.Center;
+				case TextAlignment.End:
+					return ATextAlignment.ViewEnd;
+				default:
+					return ATextAlignment.ViewStart;
+			}
+		}
+
 		internal static GravityFlags ToHorizontalGravityFlags(this TextAlignment alignment)
 		{
 			switch (alignment)
@@ -11,9 +25,9 @@ internal static GravityFlags ToHorizontalGravityFlags(this TextAlignment alignme
 				case TextAlignment.Center:
 					return GravityFlags.CenterHorizontal;
 				case TextAlignment.End:
-					return GravityFlags.Right;
+					return GravityFlags.End;
 				default:
-					return GravityFlags.Left;
+					return GravityFlags.Start;
 			}
 		}
 
diff --git a/Xamarin.Forms.Platform.Android/Renderers/EditorRenderer.cs b/Xamarin.Forms.Platform.Android/Renderers/EditorRenderer.cs
index a04d30a5342..b5d6aaea582 100644
--- a/Xamarin.Forms.Platform.Android/Renderers/EditorRenderer.cs
+++ b/Xamarin.Forms.Platform.Android/Renderers/EditorRenderer.cs
@@ -2,6 +2,7 @@
 using System.ComponentModel;
 using Android.Content;
 using Android.Content.Res;
+using Android.OS;
 using Android.Text;
 using Android.Text.Method;
 using Android.Util;
@@ -28,7 +29,7 @@ public EditorRenderer()
 			AutoPackage = false;
 		}
 
-        IEditorController ElementController => Element;
+		IEditorController ElementController => Element;
 
 		void ITextWatcher.AfterTextChanged(IEditable s)
 		{
@@ -70,6 +71,8 @@ protected override void OnElementChanged(ElementChangedEventArgs<Editor> e)
 
 			edit.SetSingleLine(false);
 			edit.Gravity = GravityFlags.Top;
+			if ((int)Build.VERSION.SdkInt > 16)
+				edit.TextAlignment = global::Android.Views.TextAlignment.ViewStart;
 			edit.SetHorizontallyScrolling(false);
 
 			UpdateText();
@@ -127,7 +130,7 @@ protected virtual NumberKeyListener GetDigitsKeyListener(InputTypes inputTypes)
 		internal override void OnNativeFocusChanged(bool hasFocus)
 		{
 			if (Element.IsFocused && !hasFocus) // Editor has requested an unfocus, fire completed event
-                ElementController.SendCompleted();
+				ElementController.SendCompleted();
 		}
 
 		void UpdateFont()
diff --git a/Xamarin.Forms.Platform.Android/Renderers/EntryRenderer.cs b/Xamarin.Forms.Platform.Android/Renderers/EntryRenderer.cs
index dda990eb2b1..f79951c3ecd 100644
--- a/Xamarin.Forms.Platform.Android/Renderers/EntryRenderer.cs
+++ b/Xamarin.Forms.Platform.Android/Renderers/EntryRenderer.cs
@@ -9,8 +9,6 @@
 using Android.Views.InputMethods;
 using Android.Widget;
 using Java.Lang;
-using Xamarin.Forms.Internals;
-using Xamarin.Forms.PlatformConfiguration.AndroidSpecific;
 
 namespace Xamarin.Forms.Platform.Android
 {
@@ -143,6 +141,8 @@ protected override void OnElementPropertyChanged(object sender, PropertyChangedE
 				UpdateFont();
 			else if (e.PropertyName == Entry.PlaceholderColorProperty.PropertyName)
 				UpdatePlaceholderColor();
+			else if (e.PropertyName == VisualElement.FlowDirectionProperty.PropertyName)
+				UpdateAlignment();
 
 			base.OnElementPropertyChanged(sender, e);
 		}
@@ -157,7 +157,7 @@ protected virtual NumberKeyListener GetDigitsKeyListener(InputTypes inputTypes)
 
 		void UpdateAlignment()
 		{
-			Control.Gravity = Element.HorizontalTextAlignment.ToHorizontalGravityFlags();
+			Control.UpdateHorizontalAlignment(Element.HorizontalTextAlignment);
 		}
 
 		void UpdateColor()
diff --git a/Xamarin.Forms.Platform.Android/Renderers/SearchBarRenderer.cs b/Xamarin.Forms.Platform.Android/Renderers/SearchBarRenderer.cs
index 2dc02d08973..2bbfb43d6b8 100644
--- a/Xamarin.Forms.Platform.Android/Renderers/SearchBarRenderer.cs
+++ b/Xamarin.Forms.Platform.Android/Renderers/SearchBarRenderer.cs
@@ -115,6 +115,8 @@ protected override void OnElementPropertyChanged(object sender, PropertyChangedE
 				UpdateTextColor();
 			else if (e.PropertyName == SearchBar.PlaceholderColorProperty.PropertyName)
 				UpdatePlaceholderColor();
+			else if (e.PropertyName == VisualElement.FlowDirectionProperty.PropertyName)
+				UpdateAlignment();
 		}
 
 		internal override void OnNativeFocusChanged(bool hasFocus)
@@ -130,7 +132,7 @@ void UpdateAlignment()
 			if (_editText == null)
 				return;
 
-			_editText.Gravity = Element.HorizontalTextAlignment.ToHorizontalGravityFlags() | Xamarin.Forms.TextAlignment.Center.ToVerticalGravityFlags();
+			_editText.UpdateHorizontalAlignment(Element.HorizontalTextAlignment);
 		}
 
 		void UpdateCancelButtonColor()
diff --git a/Xamarin.Forms.Platform.Android/Renderers/TimePickerRenderer.cs b/Xamarin.Forms.Platform.Android/Renderers/TimePickerRenderer.cs
index 9a353014a98..37f9dfe0151 100644
--- a/Xamarin.Forms.Platform.Android/Renderers/TimePickerRenderer.cs
+++ b/Xamarin.Forms.Platform.Android/Renderers/TimePickerRenderer.cs
@@ -8,6 +8,7 @@
 using ADatePicker = Android.Widget.DatePicker;
 using ATimePicker = Android.Widget.TimePicker;
 using Object = Java.Lang.Object;
+using Android.OS;
 
 namespace Xamarin.Forms.Platform.Android
 {
@@ -60,12 +61,15 @@ protected override void OnElementChanged(ElementChangedEventArgs<TimePicker> e)
 				textField.SetOnClickListener(TimePickerListener.Instance);
 				SetNativeControl(textField);
 				_textColorSwitcher = new TextColorSwitcher(textField.TextColors);
-				_is24HourFormat	= DateFormat.Is24HourFormat(Context);
+				_is24HourFormat = DateFormat.Is24HourFormat(Context);
 				_timeFormat = _is24HourFormat ? "HH:mm" : Element.Format;
 			}
 
 			SetTime(e.NewElement.Time);
 			UpdateTextColor();
+
+			if ((int)Build.VERSION.SdkInt > 16)
+				Control.TextAlignment = global::Android.Views.TextAlignment.ViewStart;
 		}
 
 		protected override void OnElementPropertyChanged(object sender, PropertyChangedEventArgs e)
@@ -73,7 +77,7 @@ protected override void OnElementPropertyChanged(object sender, PropertyChangedE
 			base.OnElementPropertyChanged(sender, e);
 
 			if (e.PropertyName == TimePicker.TimeProperty.PropertyName ||
-			    e.PropertyName == TimePicker.FormatProperty.PropertyName)
+				e.PropertyName == TimePicker.FormatProperty.PropertyName)
 				SetTime(Element.Time);
 
 			if (e.PropertyName == TimePicker.TextColorProperty.PropertyName)
@@ -103,7 +107,7 @@ void OnClick()
 		{
 			TimePicker view = Element;
 			ElementController.SetValueFromRenderer(VisualElement.IsFocusedPropertyKey, true);
-			
+
 			_dialog = new TimePickerDialog(Context, this, view.Time.Hours, view.Time.Minutes, _is24HourFormat);
 
 			if (Forms.IsLollipopOrNewer)
diff --git a/Xamarin.Forms.Platform.Android/ViewRenderer.cs b/Xamarin.Forms.Platform.Android/ViewRenderer.cs
index 25cdec846f0..216c9d65f3f 100644
--- a/Xamarin.Forms.Platform.Android/ViewRenderer.cs
+++ b/Xamarin.Forms.Platform.Android/ViewRenderer.cs
@@ -147,6 +147,8 @@ protected override void OnElementPropertyChanged(object sender, PropertyChangedE
 				UpdateIsEnabled();
 			else if (e.PropertyName == AutomationProperties.LabeledByProperty.PropertyName)
 				SetLabeledBy();
+			else if (e.PropertyName == VisualElement.FlowDirectionProperty.PropertyName)
+				UpdateFlowDirection();
 		}
 
 		protected override void OnLayout(bool changed, int l, int t, int r, int b)
@@ -319,6 +321,7 @@ internal void SetNativeControl(TNativeView control, ViewGroup container)
 			Control.OnFocusChangeListener = this;
 
 			UpdateIsEnabled();
+			UpdateFlowDirection();
 			SetLabeledBy();
 		}
 
@@ -345,5 +348,10 @@ void UpdateIsEnabled()
 			if (Control != null)
 				Control.Enabled = Element.IsEnabled;
 		}
+
+		void UpdateFlowDirection()
+		{
+			Control.UpdateFlowDirection(Element);
+		}
 	}
 }
diff --git a/Xamarin.Forms.Platform.Android/Xamarin.Forms.Platform.Android.csproj b/Xamarin.Forms.Platform.Android/Xamarin.Forms.Platform.Android.csproj
index 20a99339093..fc799a4d85b 100644
--- a/Xamarin.Forms.Platform.Android/Xamarin.Forms.Platform.Android.csproj
+++ b/Xamarin.Forms.Platform.Android/Xamarin.Forms.Platform.Android.csproj
@@ -128,6 +128,7 @@
     <Compile Include="ExportCellAttribute.cs" />
     <Compile Include="ExportImageSourceHandlerAttribute.cs" />
     <Compile Include="ExportRendererAttribute.cs" />
+    <Compile Include="Extensions\FlowDirectionExtensions.cs" />
     <Compile Include="GestureManager.cs" />
     <Compile Include="FastRenderers\LabelRenderer.cs" />
     <Compile Include="FastRenderers\VisualElementRenderer.cs" />
@@ -300,4 +301,4 @@
   <Import Project="..\packages\Xamarin.Android.Support.Animated.Vector.Drawable.25.4.0.2\build\MonoAndroid70\Xamarin.Android.Support.Animated.Vector.Drawable.targets" Condition="Exists('..\packages\Xamarin.Android.Support.Animated.Vector.Drawable.25.4.0.2\build\MonoAndroid70\Xamarin.Android.Support.Animated.Vector.Drawable.targets')" />
   <Import Project="..\packages\Xamarin.Android.Support.v7.AppCompat.25.4.0.2\build\MonoAndroid70\Xamarin.Android.Support.v7.AppCompat.targets" Condition="Exists('..\packages\Xamarin.Android.Support.v7.AppCompat.25.4.0.2\build\MonoAndroid70\Xamarin.Android.Support.v7.AppCompat.targets')" />
   <Import Project="..\packages\Xamarin.Android.Support.Design.25.4.0.2\build\MonoAndroid70\Xamarin.Android.Support.Design.targets" Condition="Exists('..\packages\Xamarin.Android.Support.Design.25.4.0.2\build\MonoAndroid70\Xamarin.Android.Support.Design.targets')" />
-</Project>
+</Project>
\ No newline at end of file
diff --git a/Xamarin.Forms.Platform.MacOS/Cells/EntryCellRenderer.cs b/Xamarin.Forms.Platform.MacOS/Cells/EntryCellRenderer.cs
index 43789dccc9f..2f4d424704f 100644
--- a/Xamarin.Forms.Platform.MacOS/Cells/EntryCellRenderer.cs
+++ b/Xamarin.Forms.Platform.MacOS/Cells/EntryCellRenderer.cs
@@ -80,6 +80,8 @@ static void OnCellPropertyChanged(object sender, PropertyChangedEventArgs e)
 				UpdateHorizontalTextAlignment(realCell, entryCell);
 			else if (e.PropertyName == Cell.IsEnabledProperty.PropertyName)
 				UpdateIsEnabled(realCell, entryCell);
+			else if (e.PropertyName == VisualElement.FlowDirectionProperty.PropertyName)
+				UpdateHorizontalTextAlignment(realCell, entryCell);
 		}
 
 		static void OnTextFieldTextChanged(object sender, EventArgs eventArgs)
@@ -101,9 +103,11 @@ static void OnTextFieldTextChanged(object sender, EventArgs eventArgs)
 
 		static void UpdateHorizontalTextAlignment(CellNSView cell, EntryCell entryCell)
 		{
+			IVisualElementController viewController = entryCell.Parent as VisualElement;
+
 			var nsTextField = cell.AccessoryView.Subviews[0] as NSTextField;
 			if (nsTextField != null)
-				nsTextField.Alignment = entryCell.HorizontalTextAlignment.ToNativeTextAlignment();
+				nsTextField.Alignment = entryCell.HorizontalTextAlignment.ToNativeTextAlignment(viewController?.EffectiveFlowDirection ?? default(EffectiveFlowDirection));
 		}
 
 		static void UpdateIsEnabled(CellNSView cell, EntryCell entryCell)
diff --git a/Xamarin.Forms.Platform.MacOS/Extensions/AlignmentExtensions.cs b/Xamarin.Forms.Platform.MacOS/Extensions/AlignmentExtensions.cs
index 35d0f26cc1f..096f451c6c2 100644
--- a/Xamarin.Forms.Platform.MacOS/Extensions/AlignmentExtensions.cs
+++ b/Xamarin.Forms.Platform.MacOS/Extensions/AlignmentExtensions.cs
@@ -1,20 +1,28 @@
 using System;
 using AppKit;
+using Xamarin.Forms.Internals;
 
 namespace Xamarin.Forms.Platform.MacOS
 {
 	internal static class AlignmentExtensions
 	{
-		internal static NSTextAlignment ToNativeTextAlignment(this TextAlignment alignment)
+		internal static NSTextAlignment ToNativeTextAlignment(this TextAlignment alignment, EffectiveFlowDirection flowDirection)
 		{
+			var isLtr = flowDirection.IsLeftToRight();
 			switch (alignment)
 			{
 				case TextAlignment.Center:
 					return NSTextAlignment.Center;
 				case TextAlignment.End:
-					return NSTextAlignment.Right;
+					if (isLtr)
+						return NSTextAlignment.Right;
+					else
+						return NSTextAlignment.Left;
 				default:
-					return NSTextAlignment.Left;
+					if (isLtr)
+						return NSTextAlignment.Left;
+					else
+						return NSTextAlignment.Natural;
 			}
 		}
 	}
diff --git a/Xamarin.Forms.Platform.MacOS/Extensions/FlowDirectionExtensions.cs b/Xamarin.Forms.Platform.MacOS/Extensions/FlowDirectionExtensions.cs
new file mode 100644
index 00000000000..a8680d5c1ef
--- /dev/null
+++ b/Xamarin.Forms.Platform.MacOS/Extensions/FlowDirectionExtensions.cs
@@ -0,0 +1,47 @@
+using AppKit;
+using Xamarin.Forms.Internals;
+
+namespace Xamarin.Forms.Platform.MacOS
+{
+	internal static class FlowDirectionExtensions
+	{
+		internal static FlowDirection ToFlowDirection(this NSApplicationLayoutDirection direction)
+		{
+			switch (direction)
+			{
+				case NSApplicationLayoutDirection.LeftToRight:
+					return FlowDirection.LeftToRight;
+				case NSApplicationLayoutDirection.RightToLeft:
+					return FlowDirection.RightToLeft;
+				default:
+					return FlowDirection.MatchParent;
+			}
+		}
+
+		internal static void UpdateFlowDirection(this NSView view, IVisualElementController controller)
+		{
+			if (controller == null || view == null)
+				return;
+
+			if (controller.EffectiveFlowDirection.IsRightToLeft())
+				view.UserInterfaceLayoutDirection = NSUserInterfaceLayoutDirection.RightToLeft;
+			else if (controller.EffectiveFlowDirection.IsLeftToRight())
+				view.UserInterfaceLayoutDirection = NSUserInterfaceLayoutDirection.LeftToRight;
+		}
+
+		internal static void UpdateFlowDirection(this NSTextField control, IVisualElementController controller)
+		{
+			if (controller == null || control == null)
+				return;
+
+			if (controller.EffectiveFlowDirection.IsRightToLeft())
+			{
+				control.Alignment = NSTextAlignment.Right;
+			}
+			else if (controller.EffectiveFlowDirection.IsLeftToRight())
+			{
+				control.Alignment = NSTextAlignment.Left;
+			}
+		}
+	}
+}
\ No newline at end of file
diff --git a/Xamarin.Forms.Platform.MacOS/Renderers/EntryRenderer.cs b/Xamarin.Forms.Platform.MacOS/Renderers/EntryRenderer.cs
index 5fb65542175..0edcb6b56c8 100644
--- a/Xamarin.Forms.Platform.MacOS/Renderers/EntryRenderer.cs
+++ b/Xamarin.Forms.Platform.MacOS/Renderers/EntryRenderer.cs
@@ -98,6 +98,8 @@ protected override void OnElementPropertyChanged(object sender, PropertyChangedE
 				UpdateColor();
 				UpdatePlaceholder();
 			}
+			else if (e.PropertyName == VisualElement.FlowDirectionProperty.PropertyName)
+				UpdateAlignment();
 
 			base.OnElementPropertyChanged(sender, e);
 		}
@@ -152,7 +154,7 @@ void OnEditingEnded(object sender, EventArgs e)
 
 		void UpdateAlignment()
 		{
-			Control.Alignment = Element.HorizontalTextAlignment.ToNativeTextAlignment();
+			Control.Alignment = Element.HorizontalTextAlignment.ToNativeTextAlignment(((IVisualElementController)Element).EffectiveFlowDirection);
 		}
 
 		void UpdateColor()
diff --git a/Xamarin.Forms.Platform.MacOS/Renderers/SearchBarRenderer.cs b/Xamarin.Forms.Platform.MacOS/Renderers/SearchBarRenderer.cs
index 994e7055afe..04716615355 100644
--- a/Xamarin.Forms.Platform.MacOS/Renderers/SearchBarRenderer.cs
+++ b/Xamarin.Forms.Platform.MacOS/Renderers/SearchBarRenderer.cs
@@ -83,6 +83,8 @@ protected override void OnElementPropertyChanged(object sender, PropertyChangedE
 				UpdateFont();
 			else if (e.PropertyName == SearchBar.HorizontalTextAlignmentProperty.PropertyName)
 				UpdateAlignment();
+			else if (e.PropertyName == VisualElement.FlowDirectionProperty.PropertyName)
+				UpdateAlignment();
 		}
 
 		protected override void SetBackgroundColor(Color color)
@@ -125,7 +127,7 @@ void OnTextChanged(object sender, EventArgs a)
 
 		void UpdateAlignment()
 		{
-			Control.Alignment = Element.HorizontalTextAlignment.ToNativeTextAlignment();
+			Control.Alignment = Element.HorizontalTextAlignment.ToNativeTextAlignment(((IVisualElementController)Element).EffectiveFlowDirection);
 		}
 
 		void UpdateCancelButton()
diff --git a/Xamarin.Forms.Platform.MacOS/Xamarin.Forms.Platform.macOS.csproj b/Xamarin.Forms.Platform.MacOS/Xamarin.Forms.Platform.macOS.csproj
index 102a4e58e4d..1ef202d9b17 100644
--- a/Xamarin.Forms.Platform.MacOS/Xamarin.Forms.Platform.macOS.csproj
+++ b/Xamarin.Forms.Platform.MacOS/Xamarin.Forms.Platform.macOS.csproj
@@ -70,6 +70,7 @@
     <Compile Include="..\Xamarin.Forms.Platform.iOS\Flags.cs">
       <Link>Flags.cs</Link>
     </Compile>
+    <Compile Include="Extensions\FlowDirectionExtensions.cs" />
     <Compile Include="FormsApplicationDelegate.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="PlatformRenderer.cs" />
diff --git a/Xamarin.Forms.Platform.UAP/MasterDetailPageRenderer.cs b/Xamarin.Forms.Platform.UAP/MasterDetailPageRenderer.cs
index 5d358c8d0a6..523f734f56b 100644
--- a/Xamarin.Forms.Platform.UAP/MasterDetailPageRenderer.cs
+++ b/Xamarin.Forms.Platform.UAP/MasterDetailPageRenderer.cs
@@ -2,7 +2,6 @@
 using System.ComponentModel;
 using System.Threading.Tasks;
 using Windows.UI.Xaml;
-using Windows.UI.Xaml.Automation;
 using Windows.UI.Xaml.Controls;
 using Windows.UI.Xaml.Data;
 using Windows.UI.Xaml.Media;
@@ -18,7 +17,7 @@ public class MasterDetailPageRenderer : IVisualElementRenderer, IToolbarProvider
 		bool _showTitle;
 
 		VisualElementTracker<Page, FrameworkElement> _tracker;
-
+		
 		public MasterDetailControl Control { get; private set; }
 
 		public MasterDetailPage Element { get; private set; }
@@ -169,6 +168,8 @@ protected virtual void OnElementPropertyChanged(object sender, PropertyChangedEv
 				UpdateMode();
 			else if(e.PropertyName ==  PlatformConfiguration.WindowsSpecific.Page.ToolbarPlacementProperty.PropertyName)
 				UpdateToolbarPlacement();
+			else if (e.PropertyName == VisualElement.FlowDirectionProperty.PropertyName)
+				UpdateFlowDirection();
 		}
 
 		void ClearDetail()
@@ -208,6 +209,7 @@ void OnControlLoaded(object sender, RoutedEventArgs routedEventArgs)
 
 			Element.SendAppearing();
 			UpdateBounds();
+			UpdateFlowDirection();
 		}
 
 		void OnControlUnloaded(object sender, RoutedEventArgs routedEventArgs)
@@ -277,6 +279,11 @@ void UpdateDetailTitle()
 			(this as ITitleProvider).ShowTitle = !string.IsNullOrEmpty(Control.DetailTitle);
 		}
 
+		void UpdateFlowDirection()
+		{
+			Control.UpdateFlowDirection(Element);
+		}
+
 		void UpdateIsPresented()
 		{
 			// Ignore the IsPresented value being set to false for Split mode on desktop and allow the master
diff --git a/Xamarin.Forms.Platform.UAP/Resources.xaml b/Xamarin.Forms.Platform.UAP/Resources.xaml
index f109e756bea..db839a5c17d 100644
--- a/Xamarin.Forms.Platform.UAP/Resources.xaml
+++ b/Xamarin.Forms.Platform.UAP/Resources.xaml
@@ -408,7 +408,7 @@
 	</DataTemplate>
 	
 	<DataTemplate x:Key="SwitchCell">
-		<Grid HorizontalAlignment="Stretch">
+		<Grid HorizontalAlignment="Stretch" x:Name="ParentGrid">
 			<Grid.ColumnDefinitions>
 				<ColumnDefinition Width="*" />
 				<ColumnDefinition Width="Auto" />
@@ -416,7 +416,7 @@
 
 			<TextBlock Grid.Column="0" Text="{Binding Text}" VerticalAlignment="Center" Style="{ThemeResource BaseTextBlockStyle}" />
 
-			<ToggleSwitch Grid.Column="1" IsOn="{Binding On, Mode=TwoWay}" OnContent="" OffContent="" VerticalAlignment="Center" />
+			<ToggleSwitch Grid.Column="1" IsOn="{Binding On, Mode=TwoWay}" OnContent="" OffContent="" VerticalAlignment="Center" FlowDirection="{Binding FlowDirection, ElementName=ParentGrid }" />
 		</Grid>
 	</DataTemplate>
 
diff --git a/Xamarin.Forms.Platform.UAP/SearchBarRenderer.cs b/Xamarin.Forms.Platform.UAP/SearchBarRenderer.cs
index 6a3ee730f82..216230eb500 100644
--- a/Xamarin.Forms.Platform.UAP/SearchBarRenderer.cs
+++ b/Xamarin.Forms.Platform.UAP/SearchBarRenderer.cs
@@ -63,6 +63,8 @@ protected override void OnElementPropertyChanged(object sender, PropertyChangedE
 				UpdateTextColor();
 			else if (e.PropertyName == SearchBar.PlaceholderColorProperty.PropertyName)
 				UpdatePlaceholderColor();
+			else if (e.PropertyName == VisualElement.FlowDirectionProperty.PropertyName)
+				UpdateAlignment();
 		}
 
 		void OnControlLoaded(object sender, RoutedEventArgs routedEventArgs)
@@ -92,7 +94,7 @@ void UpdateAlignment()
 			if (_queryTextBox == null)
 				return;
 
-			_queryTextBox.TextAlignment = Element.HorizontalTextAlignment.ToNativeTextAlignment();
+			_queryTextBox.TextAlignment = Element.HorizontalTextAlignment.ToNativeTextAlignment(((IVisualElementController)Element).EffectiveFlowDirection);
 		}
 
 		void UpdateCancelButtonColor()
diff --git a/Xamarin.Forms.Platform.UAP/Xamarin.Forms.Platform.UAP.csproj b/Xamarin.Forms.Platform.UAP/Xamarin.Forms.Platform.UAP.csproj
index 2aaafeb0095..27542270631 100644
--- a/Xamarin.Forms.Platform.UAP/Xamarin.Forms.Platform.UAP.csproj
+++ b/Xamarin.Forms.Platform.UAP/Xamarin.Forms.Platform.UAP.csproj
@@ -134,6 +134,9 @@
     <Compile Include="..\Xamarin.Forms.Platform.WinRT\BrushHelpers.cs">
       <Link>BrushHelpers.cs</Link>
     </Compile>
+    <Compile Include="..\Xamarin.Forms.Platform.WinRT\FlowDirectionExtensions.cs">
+      <Link>FlowDirectionExtensions.cs</Link>
+    </Compile>
     <Compile Include="..\Xamarin.Forms.Platform.WinRT\FormsProgressBar.cs">
       <Link>FormsProgressBar.cs</Link>
     </Compile>
diff --git a/Xamarin.Forms.Platform.WinRT.Tablet/Forms.cs b/Xamarin.Forms.Platform.WinRT.Tablet/Forms.cs
index f81a4b21949..554642ff2a7 100644
--- a/Xamarin.Forms.Platform.WinRT.Tablet/Forms.cs
+++ b/Xamarin.Forms.Platform.WinRT.Tablet/Forms.cs
@@ -4,6 +4,7 @@
 using System.Linq;
 using System.Reflection;
 using Windows.ApplicationModel.Activation;
+using Windows.ApplicationModel.Resources.Core;
 using Windows.Foundation.Metadata;
 using Windows.UI;
 using Windows.UI.Core;
@@ -48,6 +49,7 @@ public static void Init(IActivatedEventArgs launchActivatedEventArgs)
 			Windows.UI.Xaml.Application.Current.Resources.MergedDictionaries.Add(GetTabletResources());
 
 			Device.SetIdiom(TargetIdiom.Tablet);
+			Device.SetFlowDirection(GetFlowDirection());
 			Device.PlatformServices = new WindowsPlatformServices(Window.Current.Dispatcher);
 #if WINDOWS_UWP
 			Device.SetFlags(s_flags);
@@ -96,6 +98,17 @@ static Windows.Foundation.Metadata.Platform DetectPlatform()
 			return Windows.Foundation.Metadata.Platform.Windows;
 		}
 
+		static FlowDirection GetFlowDirection()
+		{
+			string resourceFlowDirection = ResourceContext.GetForCurrentView().QualifierValues["LayoutDirection"];
+			if (resourceFlowDirection == "LTR")
+				return FlowDirection.LeftToRight;
+			else if (resourceFlowDirection == "RTL")
+				return FlowDirection.RightToLeft;
+
+			return FlowDirection.MatchParent;
+		}
+
 		static Windows.UI.Xaml.ResourceDictionary GetTabletResources()
 		{
 			return new Windows.UI.Xaml.ResourceDictionary {
diff --git a/Xamarin.Forms.Platform.WinRT/AlignmentExtensions.cs b/Xamarin.Forms.Platform.WinRT/AlignmentExtensions.cs
index aa6f926aad5..cfafa6c972e 100644
--- a/Xamarin.Forms.Platform.WinRT/AlignmentExtensions.cs
+++ b/Xamarin.Forms.Platform.WinRT/AlignmentExtensions.cs
@@ -1,4 +1,5 @@
 using Windows.UI.Xaml;
+using Xamarin.Forms.Internals;
 
 #if WINDOWS_UWP
 
@@ -10,16 +11,23 @@ namespace Xamarin.Forms.Platform.WinRT
 {
 	internal static class AlignmentExtensions
 	{
-		internal static Windows.UI.Xaml.TextAlignment ToNativeTextAlignment(this TextAlignment alignment)
+		internal static Windows.UI.Xaml.TextAlignment ToNativeTextAlignment(this TextAlignment alignment, EffectiveFlowDirection flowDirection = default(EffectiveFlowDirection))
 		{
+			var isLtr = flowDirection.IsLeftToRight();
 			switch (alignment)
 			{
 				case TextAlignment.Center:
 					return Windows.UI.Xaml.TextAlignment.Center;
 				case TextAlignment.End:
-					return Windows.UI.Xaml.TextAlignment.Right;
+					if (isLtr)
+						return Windows.UI.Xaml.TextAlignment.Right;
+					else
+						return Windows.UI.Xaml.TextAlignment.Left;
 				default:
-					return Windows.UI.Xaml.TextAlignment.Left;
+					if (isLtr)
+						return Windows.UI.Xaml.TextAlignment.Left;
+					else
+						return Windows.UI.Xaml.TextAlignment.Right;
 			}
 		}
 
diff --git a/Xamarin.Forms.Platform.WinRT/CellControl.cs b/Xamarin.Forms.Platform.WinRT/CellControl.cs
index 72043f801aa..d90804f6769 100644
--- a/Xamarin.Forms.Platform.WinRT/CellControl.cs
+++ b/Xamarin.Forms.Platform.WinRT/CellControl.cs
@@ -142,6 +142,8 @@ void OnCellPropertyChanged(object sender, PropertyChangedEventArgs e)
 			{
 				SetupContextMenu();
 			}
+			else if (e.PropertyName == VisualElement.FlowDirectionProperty.PropertyName)
+				UpdateFlowDirection(Cell);
 		}
 
 		void OnClick(object sender, PointerRoutedEventArgs e)
@@ -263,6 +265,7 @@ void SetSource(Cell oldCell, Cell newCell)
 				newCell.SendAppearing();
 
 				UpdateContent(newCell);
+				UpdateFlowDirection(newCell);
 				SetupContextMenu();
 
 				newCell.PropertyChanged += _propertyChangedHandler;
@@ -316,5 +319,13 @@ void UpdateContent(Cell newCell)
 
 			((FrameworkElement)Content).DataContext = newCell;
 		}
+
+		void UpdateFlowDirection(Cell newCell)
+		{
+			if (newCell is ViewCell)
+				return;
+
+			this.UpdateFlowDirection(newCell.Parent as VisualElement);
+		}
 	}
 }
\ No newline at end of file
diff --git a/Xamarin.Forms.Platform.WinRT/DatePickerRenderer.cs b/Xamarin.Forms.Platform.WinRT/DatePickerRenderer.cs
index 77f05236cd4..ce37f8fcdeb 100644
--- a/Xamarin.Forms.Platform.WinRT/DatePickerRenderer.cs
+++ b/Xamarin.Forms.Platform.WinRT/DatePickerRenderer.cs
@@ -43,6 +43,7 @@ protected override void OnElementChanged(ElementChangedEventArgs<DatePicker> e)
 				UpdateMinimumDate();
 				UpdateMaximumDate();
 				UpdateDate(e.NewElement.Date);
+				UpdateFlowDirection();
 			}
 
 			base.OnElementChanged(e);
@@ -68,6 +69,8 @@ protected override void OnElementPropertyChanged(object sender, PropertyChangedE
 				UpdateMinimumDate();
 			else if (e.PropertyName == DatePicker.TextColorProperty.PropertyName)
 				UpdateTextColor();
+			else if (e.PropertyName == VisualElement.FlowDirectionProperty.PropertyName)
+				UpdateFlowDirection();
 		}
 
 		protected override bool PreventGestureBubbling { get; set; } = true;
@@ -87,6 +90,11 @@ void UpdateDate(DateTime date)
 			Control.Date = date;
 		}
 
+		void UpdateFlowDirection()
+		{
+			Control.UpdateFlowDirection(Element);
+		}
+
 		void UpdateMaximumDate()
 		{
 			DateTime maxdate = Element.MaximumDate;
diff --git a/Xamarin.Forms.Platform.WinRT/EditorRenderer.cs b/Xamarin.Forms.Platform.WinRT/EditorRenderer.cs
index 88ec6120924..67523eb4e32 100644
--- a/Xamarin.Forms.Platform.WinRT/EditorRenderer.cs
+++ b/Xamarin.Forms.Platform.WinRT/EditorRenderer.cs
@@ -44,6 +44,8 @@ protected override void OnElementChanged(ElementChangedEventArgs<Editor> e)
 				UpdateInputScope();
 				UpdateTextColor();
 				UpdateFont();
+				UpdateTextAlignment();
+				UpdateFlowDirection();
 			}
 
 			base.OnElementChanged(e);
@@ -84,6 +86,11 @@ protected override void OnElementPropertyChanged(object sender, PropertyChangedE
 			{
 				UpdateText();
 			}
+			else if (e.PropertyName == VisualElement.FlowDirectionProperty.PropertyName)
+			{
+				UpdateTextAlignment();
+				UpdateFlowDirection();
+			}
 		}
 
 		void OnLostFocus(object sender, RoutedEventArgs e)
@@ -174,6 +181,11 @@ void UpdateText()
 			Control.SelectionStart = Control.Text.Length;
 		}
 
+		void UpdateTextAlignment()
+		{
+			Control.UpdateTextAlignment(Element);
+		}
+
 		void UpdateTextColor()
 		{
 			Color textColor = Element.TextColor;
@@ -184,5 +196,10 @@ void UpdateTextColor()
 			BrushHelpers.UpdateColor(textColor, ref _defaultTextColorFocusBrush,
 				() => Control.ForegroundFocusBrush, brush => Control.ForegroundFocusBrush = brush);
 		}
+
+		void UpdateFlowDirection()
+		{
+			Control.UpdateFlowDirection(Element);
+		}
 	}
 }
\ No newline at end of file
diff --git a/Xamarin.Forms.Platform.WinRT/EntryRenderer.cs b/Xamarin.Forms.Platform.WinRT/EntryRenderer.cs
index 06ec6f2be14..4181e4efb6a 100644
--- a/Xamarin.Forms.Platform.WinRT/EntryRenderer.cs
+++ b/Xamarin.Forms.Platform.WinRT/EntryRenderer.cs
@@ -87,6 +87,8 @@ protected override void OnElementPropertyChanged(object sender, PropertyChangedE
 				UpdateAlignment();
 			else if (e.PropertyName == Entry.PlaceholderColorProperty.PropertyName)
 				UpdatePlaceholderColor();
+			else if (e.PropertyName == VisualElement.FlowDirectionProperty.PropertyName)
+				UpdateAlignment();
 		}
 
 		protected override void UpdateBackgroundColor()
@@ -126,7 +128,7 @@ void TextBoxOnKeyUp(object sender, KeyRoutedEventArgs args)
 
 		void UpdateAlignment()
 		{
-			Control.TextAlignment = Element.HorizontalTextAlignment.ToNativeTextAlignment();
+			Control.TextAlignment = Element.HorizontalTextAlignment.ToNativeTextAlignment(((IVisualElementController)Element).EffectiveFlowDirection);
 		}
 
 		void UpdateFont()
diff --git a/Xamarin.Forms.Platform.WinRT/FlowDirectionExtensions.cs b/Xamarin.Forms.Platform.WinRT/FlowDirectionExtensions.cs
new file mode 100644
index 00000000000..135e6c4b320
--- /dev/null
+++ b/Xamarin.Forms.Platform.WinRT/FlowDirectionExtensions.cs
@@ -0,0 +1,37 @@
+using Windows.UI.Xaml;
+using WFlowDirection = Windows.UI.Xaml.FlowDirection;
+using WTextAlignment = Windows.UI.Xaml.TextAlignment;
+using Xamarin.Forms.Internals;
+using Windows.UI.Xaml.Controls;
+
+#if WINDOWS_UWP
+namespace Xamarin.Forms.Platform.UWP
+#else
+namespace Xamarin.Forms.Platform.WinRT
+#endif
+{
+	internal static class FlowDirectionExtensions
+	{
+		internal static void UpdateFlowDirection(this FrameworkElement control, IVisualElementController controller)
+		{
+			if (controller == null || control == null)
+				return;
+
+			if (controller.EffectiveFlowDirection.IsRightToLeft())
+				control.FlowDirection = WFlowDirection.RightToLeft;
+			else if (controller.EffectiveFlowDirection.IsLeftToRight())
+				control.FlowDirection = WFlowDirection.LeftToRight;
+		}
+
+		internal static void UpdateTextAlignment(this TextBox control, IVisualElementController controller)
+		{
+			if (controller == null || control == null)
+				return;
+
+			if (controller.EffectiveFlowDirection.IsRightToLeft())
+				control.TextAlignment = WTextAlignment.Right;
+			else if (controller.EffectiveFlowDirection.IsLeftToRight())
+				control.TextAlignment = WTextAlignment.Left;
+		}
+	}
+}
diff --git a/Xamarin.Forms.Platform.WinRT/LabelRenderer.cs b/Xamarin.Forms.Platform.WinRT/LabelRenderer.cs
index 18db96116a0..c33e274b9ee 100644
--- a/Xamarin.Forms.Platform.WinRT/LabelRenderer.cs
+++ b/Xamarin.Forms.Platform.WinRT/LabelRenderer.cs
@@ -147,6 +147,8 @@ protected override void OnElementPropertyChanged(object sender, PropertyChangedE
 				UpdateFont(Control);
 			else if (e.PropertyName == Label.LineBreakModeProperty.PropertyName)
 				UpdateLineBreakMode(Control);
+			else if (e.PropertyName == VisualElement.FlowDirectionProperty.PropertyName)
+				UpdateAlign(Control);
 
 			base.OnElementPropertyChanged(sender, e);
 		}
@@ -162,7 +164,7 @@ void UpdateAlign(TextBlock textBlock)
 			if (label == null)
 				return;
 
-			textBlock.TextAlignment = label.HorizontalTextAlignment.ToNativeTextAlignment();
+			textBlock.TextAlignment = label.HorizontalTextAlignment.ToNativeTextAlignment(((IVisualElementController)Element).EffectiveFlowDirection);
 			textBlock.VerticalAlignment = label.VerticalTextAlignment.ToNativeVerticalAlignment();
 		}
 
diff --git a/Xamarin.Forms.Platform.WinRT/ProgressBarRenderer.cs b/Xamarin.Forms.Platform.WinRT/ProgressBarRenderer.cs
index b805b2f6e1c..bf6d7bcd656 100644
--- a/Xamarin.Forms.Platform.WinRT/ProgressBarRenderer.cs
+++ b/Xamarin.Forms.Platform.WinRT/ProgressBarRenderer.cs
@@ -41,6 +41,7 @@ protected override void OnElementChanged(ElementChangedEventArgs<ProgressBar> e)
 				}
 
 				Control.Value = e.NewElement.Progress;
+				UpdateFlowDirection();
 			}
 		}
 
@@ -50,11 +51,18 @@ protected override void OnElementPropertyChanged(object sender, PropertyChangedE
 
 			if (e.PropertyName == ProgressBar.ProgressProperty.PropertyName)
 				Control.Value = Element.Progress;
+			else if (e.PropertyName == VisualElement.FlowDirectionProperty.PropertyName)
+				UpdateFlowDirection();
 		}
 
 		void ProgressBarOnValueChanged(object sender, RangeBaseValueChangedEventArgs rangeBaseValueChangedEventArgs)
 		{
 			((IVisualElementController)Element)?.InvalidateMeasure(InvalidationTrigger.MeasureChanged);
 		}
+
+		void UpdateFlowDirection()
+		{
+			Control.UpdateFlowDirection(Element);
+		}
 	}
 }
\ No newline at end of file
diff --git a/Xamarin.Forms.Platform.WinRT/SliderRenderer.cs b/Xamarin.Forms.Platform.WinRT/SliderRenderer.cs
index 96fd9258e33..90edb604a9a 100644
--- a/Xamarin.Forms.Platform.WinRT/SliderRenderer.cs
+++ b/Xamarin.Forms.Platform.WinRT/SliderRenderer.cs
@@ -53,6 +53,7 @@ protected override void OnElementChanged(ElementChangedEventArgs<Slider> e)
 				double stepping = Math.Min((e.NewElement.Maximum - e.NewElement.Minimum) / 10, 1);
 				Control.StepFrequency = stepping;
 				Control.SmallChange = stepping;
+				UpdateFlowDirection();
 			}
 		}
 
@@ -69,6 +70,8 @@ protected override void OnElementPropertyChanged(object sender, PropertyChangedE
 				if (Control.Value != Element.Value)
 					Control.Value = Element.Value;
 			}
+			else if (e.PropertyName == VisualElement.FlowDirectionProperty.PropertyName)
+				UpdateFlowDirection();
 		}
 
 		protected override void UpdateBackgroundColor()
@@ -87,6 +90,11 @@ protected override void UpdateBackgroundColor()
 			}
 		}
 
+		void UpdateFlowDirection()
+		{
+			Control.UpdateFlowDirection(Element);
+		}
+
 		protected override bool PreventGestureBubbling { get; set; } = true;
 
 		void OnNativeValueChanged(object sender, RangeBaseValueChangedEventArgs e)
diff --git a/Xamarin.Forms.Platform.WinRT/StepperRenderer.cs b/Xamarin.Forms.Platform.WinRT/StepperRenderer.cs
index 796ef562f0f..e009922f230 100644
--- a/Xamarin.Forms.Platform.WinRT/StepperRenderer.cs
+++ b/Xamarin.Forms.Platform.WinRT/StepperRenderer.cs
@@ -26,7 +26,8 @@ protected override void OnElementChanged(ElementChangedEventArgs<Stepper> e)
 				UpdateMaximum();
 				UpdateMinimum();
 				UpdateValue();
-				UpdateIncrement();
+				UpdateIncrement(); 
+				UpdateFlowDirection();
 			}
 		}
 
@@ -44,6 +45,8 @@ protected override void OnElementPropertyChanged(object sender, PropertyChangedE
 				UpdateIncrement();
 			else if (e.PropertyName == VisualElement.BackgroundColorProperty.PropertyName)
 				UpdateBackgroundColor();
+			else if (e.PropertyName == VisualElement.FlowDirectionProperty.PropertyName)
+				UpdateFlowDirection();
 		}
 
 		protected override void UpdateBackgroundColor()
@@ -59,6 +62,11 @@ void OnControlValue(object sender, EventArgs e)
 			Element.SetValueCore(Stepper.ValueProperty, Control.Value);
 		}
 
+		void UpdateFlowDirection()
+		{
+			Control.UpdateFlowDirection(Element);
+		}
+
 		void UpdateIncrement()
 		{
 			Control.Increment = Element.Increment;
diff --git a/Xamarin.Forms.Platform.WinRT/SwitchRenderer.cs b/Xamarin.Forms.Platform.WinRT/SwitchRenderer.cs
index 05de07a406c..be1be21f54a 100644
--- a/Xamarin.Forms.Platform.WinRT/SwitchRenderer.cs
+++ b/Xamarin.Forms.Platform.WinRT/SwitchRenderer.cs
@@ -29,6 +29,8 @@ protected override void OnElementChanged(ElementChangedEventArgs<Switch> e)
 				}
 
 				Control.IsOn = Element.IsToggled;
+
+				UpdateFlowDirection();
 			}
 		}
 
@@ -40,6 +42,10 @@ protected override void OnElementPropertyChanged(object sender, PropertyChangedE
 			{
 				Control.IsOn = Element.IsToggled;
 			}
+			else if (e.PropertyName == VisualElement.FlowDirectionProperty.PropertyName)
+			{
+				UpdateFlowDirection();
+			}
 		}
 
 		protected override bool PreventGestureBubbling { get; set; } = true;
@@ -48,5 +54,10 @@ void OnNativeToggled(object sender, RoutedEventArgs routedEventArgs)
 		{
 			((IElementController)Element).SetValueFromRenderer(Switch.IsToggledProperty, Control.IsOn);
 		}
+
+		void UpdateFlowDirection()
+		{
+			Control.UpdateFlowDirection(Element);
+		}
 	}
 }
\ No newline at end of file
diff --git a/Xamarin.Forms.Platform.WinRT/TimePickerRenderer.cs b/Xamarin.Forms.Platform.WinRT/TimePickerRenderer.cs
index 336edd3093a..adc1613b159 100644
--- a/Xamarin.Forms.Platform.WinRT/TimePickerRenderer.cs
+++ b/Xamarin.Forms.Platform.WinRT/TimePickerRenderer.cs
@@ -43,6 +43,7 @@ protected override void OnElementChanged(ElementChangedEventArgs<TimePicker> e)
 				}
 
 				UpdateTime();
+				UpdateFlowDirection();
 			}
 		}
 
@@ -63,6 +64,9 @@ protected override void OnElementPropertyChanged(object sender, PropertyChangedE
 
 			if (e.PropertyName == TimePicker.TextColorProperty.PropertyName)
 				UpdateTextColor();
+
+			if (e.PropertyName == VisualElement.FlowDirectionProperty.PropertyName)
+				UpdateFlowDirection();
 		}
 
 		protected override bool PreventGestureBubbling { get; set; } = true;
@@ -73,6 +77,11 @@ void OnControlTimeChanged(object sender, TimePickerValueChangedEventArgs e)
 			((IVisualElementController)Element)?.InvalidateMeasure(InvalidationTrigger.SizeRequestChanged);
 		}
 
+		void UpdateFlowDirection()
+		{
+			Control.UpdateFlowDirection(Element);
+		}
+
 		void UpdateTime()
 		{
 			Control.Time = Element.Time;
diff --git a/Xamarin.Forms.Platform.WinRT/ViewRenderer.cs b/Xamarin.Forms.Platform.WinRT/ViewRenderer.cs
index 936e45c52d6..a5d72512975 100644
--- a/Xamarin.Forms.Platform.WinRT/ViewRenderer.cs
+++ b/Xamarin.Forms.Platform.WinRT/ViewRenderer.cs
@@ -1,5 +1,4 @@
 using Windows.UI.Xaml;
-using Windows.UI.Xaml.Automation;
 using Windows.UI.Xaml.Automation.Peers;
 
 #if WINDOWS_UWP
@@ -24,6 +23,7 @@ protected override void OnElementChanged(ElementChangedEventArgs<TElement> e)
 			if (e.NewElement != null)
 			{
 				UpdateBackgroundColor();
+				UpdateFlowDirection();
 			}
 		}
 
@@ -131,5 +131,10 @@ protected override void SetAutomationPropertiesLabeledBy()
 			else
 				Control.SetValue(Windows.UI.Xaml.Automation.AutomationProperties.LabeledByProperty, _defaultAutomationPropertiesLabeledBy);
 		}
+
+		void UpdateFlowDirection()
+		{
+			Control.UpdateFlowDirection(Element);
+		}
 	}
 }
\ No newline at end of file
diff --git a/Xamarin.Forms.Platform.WinRT/Xamarin.Forms.Platform.WinRT.csproj b/Xamarin.Forms.Platform.WinRT/Xamarin.Forms.Platform.WinRT.csproj
index b6453eb45b3..a2b2f32ed36 100644
--- a/Xamarin.Forms.Platform.WinRT/Xamarin.Forms.Platform.WinRT.csproj
+++ b/Xamarin.Forms.Platform.WinRT/Xamarin.Forms.Platform.WinRT.csproj
@@ -66,10 +66,10 @@
     <Compile Include="..\Xamarin.Forms.Core\Properties\GlobalAssemblyInfo.cs">
       <Link>Properties\GlobalAssemblyInfo.cs</Link>
     </Compile>
-   
+    <Compile Include="FlowDirectionExtensions.cs" />
   </ItemGroup>
   <ItemGroup Condition=" '$(OS)' != 'Unix' ">
-	<Compile Include="PageControl.cs" />
+    <Compile Include="PageControl.cs" />
     <Compile Include="NavigationPageRendererWinRT.cs" />
     <Compile Include="PlatformWinRT.cs" />
     <Compile Include="BrushHelpers.cs" />
diff --git a/Xamarin.Forms.Platform.iOS/Cells/EntryCellRenderer.cs b/Xamarin.Forms.Platform.iOS/Cells/EntryCellRenderer.cs
index b00ff9dd8f5..72e95244494 100644
--- a/Xamarin.Forms.Platform.iOS/Cells/EntryCellRenderer.cs
+++ b/Xamarin.Forms.Platform.iOS/Cells/EntryCellRenderer.cs
@@ -63,6 +63,8 @@ static void OnCellPropertyChanged(object sender, PropertyChangedEventArgs e)
 				UpdateHorizontalTextAlignment(realCell, entryCell);
 			else if (e.PropertyName == Cell.IsEnabledProperty.PropertyName)
 				UpdateIsEnabled(realCell, entryCell);
+			else if (e.PropertyName == VisualElement.FlowDirectionProperty.PropertyName)
+				UpdateHorizontalTextAlignment(realCell, entryCell);
 		}
 
 		static void OnKeyBoardDoneButtonPressed(object sender, EventArgs e)
@@ -83,7 +85,8 @@ static void OnTextFieldTextChanged(object sender, EventArgs eventArgs)
 
 		static void UpdateHorizontalTextAlignment(EntryCellTableViewCell cell, EntryCell entryCell)
 		{
-			cell.TextField.TextAlignment = entryCell.HorizontalTextAlignment.ToNativeTextAlignment();
+			IViewController viewController = entryCell.Parent as View;
+			cell.TextField.TextAlignment = entryCell.HorizontalTextAlignment.ToNativeTextAlignment(viewController?.EffectiveFlowDirection ?? default(EffectiveFlowDirection));
 		}
 
 		static void UpdateIsEnabled(EntryCellTableViewCell cell, EntryCell entryCell)
diff --git a/Xamarin.Forms.Platform.iOS/Cells/SwitchCellRenderer.cs b/Xamarin.Forms.Platform.iOS/Cells/SwitchCellRenderer.cs
index d93ec5c14a7..c66108f6203 100644
--- a/Xamarin.Forms.Platform.iOS/Cells/SwitchCellRenderer.cs
+++ b/Xamarin.Forms.Platform.iOS/Cells/SwitchCellRenderer.cs
@@ -43,6 +43,7 @@ public override UITableViewCell GetCell(Cell item, UITableViewCell reusableCell,
 
 			UpdateBackground(tvc, item);
 			UpdateIsEnabled(tvc, boolCell);
+			UpdateFlowDirection(tvc, boolCell);
 
 			return tvc;
 		}
@@ -58,6 +59,8 @@ void OnCellPropertyChanged(object sender, PropertyChangedEventArgs e)
 				realCell.TextLabel.Text = boolCell.Text;
 			else if (e.PropertyName == Cell.IsEnabledProperty.PropertyName)
 				UpdateIsEnabled(realCell, boolCell);
+			else if (e.PropertyName == VisualElement.FlowDirectionProperty.PropertyName)
+				UpdateFlowDirection(realCell, boolCell);
 		}
 
 		void OnSwitchValueChanged(object sender, EventArgs eventArgs)
@@ -76,6 +79,15 @@ void OnSwitchValueChanged(object sender, EventArgs eventArgs)
 				((SwitchCell)realCell.Cell).On = sw.On;
 		}
 
+		void UpdateFlowDirection(CellTableViewCell cell, SwitchCell switchCell)
+		{
+			IVisualElementController controller = switchCell.Parent as View;
+
+			var uiSwitch = cell.AccessoryView as UISwitch;
+
+			uiSwitch.UpdateFlowDirection(controller);
+		}
+
 		void UpdateIsEnabled(CellTableViewCell cell, SwitchCell switchCell)
 		{
 			cell.UserInteractionEnabled = switchCell.IsEnabled;
diff --git a/Xamarin.Forms.Platform.iOS/Extensions/FlowDirectionExtensions.cs b/Xamarin.Forms.Platform.iOS/Extensions/FlowDirectionExtensions.cs
new file mode 100644
index 00000000000..33e6f4945f3
--- /dev/null
+++ b/Xamarin.Forms.Platform.iOS/Extensions/FlowDirectionExtensions.cs
@@ -0,0 +1,61 @@
+using UIKit;
+using Xamarin.Forms.Internals;
+
+namespace Xamarin.Forms.Platform.iOS
+{
+	internal static class FlowDirectionExtensions
+	{
+		internal static FlowDirection ToFlowDirection(this UIUserInterfaceLayoutDirection direction)
+		{
+			switch (direction)
+			{
+				case UIUserInterfaceLayoutDirection.LeftToRight:
+					return FlowDirection.LeftToRight;
+				case UIUserInterfaceLayoutDirection.RightToLeft:
+					return FlowDirection.RightToLeft;
+				default:
+					return FlowDirection.MatchParent;
+			}
+		}
+
+		internal static void UpdateFlowDirection(this UIView view, IVisualElementController controller)
+		{
+			if (controller == null || view == null)
+				return;
+
+
+			if (controller.EffectiveFlowDirection.IsRightToLeft())
+				view.SemanticContentAttribute = UISemanticContentAttribute.ForceRightToLeft;
+			else if (controller.EffectiveFlowDirection.IsLeftToRight())
+				view.SemanticContentAttribute = UISemanticContentAttribute.ForceLeftToRight;
+		}
+
+		internal static void UpdateTextAlignment(this UITextField control, IVisualElementController controller)
+		{
+			if (controller == null || control == null)
+				return;
+
+			if (controller.EffectiveFlowDirection.IsRightToLeft())
+			{
+				control.HorizontalAlignment = UIControlContentHorizontalAlignment.Right;
+				control.TextAlignment = UITextAlignment.Right;
+			}
+			else if (controller.EffectiveFlowDirection.IsLeftToRight())
+			{
+				control.HorizontalAlignment = UIControlContentHorizontalAlignment.Left;
+				control.TextAlignment = UITextAlignment.Left;
+			}
+		}
+
+		internal static void UpdateTextAlignment(this UITextView control, IVisualElementController controller)
+		{
+			if (controller == null || control == null)
+				return;
+
+			if (controller.EffectiveFlowDirection.IsRightToLeft())
+				control.TextAlignment = UITextAlignment.Right;
+			else if (controller.EffectiveFlowDirection.IsLeftToRight())
+				control.TextAlignment = UITextAlignment.Left;
+		}
+	}
+}
\ No newline at end of file
diff --git a/Xamarin.Forms.Platform.iOS/Forms.cs b/Xamarin.Forms.Platform.iOS/Forms.cs
index 47b87730803..13d64dff166 100644
--- a/Xamarin.Forms.Platform.iOS/Forms.cs
+++ b/Xamarin.Forms.Platform.iOS/Forms.cs
@@ -101,8 +101,10 @@ public static void Init()
 
 #if __MOBILE__
 			Device.SetIdiom(UIDevice.CurrentDevice.UserInterfaceIdiom == UIUserInterfaceIdiom.Pad ? TargetIdiom.Tablet : TargetIdiom.Phone);
+			Device.SetFlowDirection(UIApplication.SharedApplication.UserInterfaceLayoutDirection.ToFlowDirection());
 #else
 			Device.SetIdiom(TargetIdiom.Desktop);
+			Device.SetFlowDirection(NSApplication.SharedApplication.UserInterfaceLayoutDirection.ToFlowDirection());
 #endif
 			Device.SetFlags(s_flags);
 			Device.PlatformServices = new IOSPlatformServices();
diff --git a/Xamarin.Forms.Platform.iOS/Renderers/AlignmentExtensions.cs b/Xamarin.Forms.Platform.iOS/Renderers/AlignmentExtensions.cs
index e6ae550f3dd..0e384cd21f8 100644
--- a/Xamarin.Forms.Platform.iOS/Renderers/AlignmentExtensions.cs
+++ b/Xamarin.Forms.Platform.iOS/Renderers/AlignmentExtensions.cs
@@ -1,19 +1,27 @@
 using UIKit;
+using Xamarin.Forms.Internals;
 
 namespace Xamarin.Forms.Platform.iOS
 {
 	internal static class AlignmentExtensions
 	{
-		internal static UITextAlignment ToNativeTextAlignment(this TextAlignment alignment)
+		internal static UITextAlignment ToNativeTextAlignment(this TextAlignment alignment, EffectiveFlowDirection flowDirection)
 		{
+			var isLtr = flowDirection.IsLeftToRight();
 			switch (alignment)
 			{
 				case TextAlignment.Center:
 					return UITextAlignment.Center;
 				case TextAlignment.End:
-					return UITextAlignment.Right;
+					if (isLtr)
+						return UITextAlignment.Right;
+					else
+						return UITextAlignment.Left;
 				default:
-					return UITextAlignment.Left;
+					if (isLtr)
+						return UITextAlignment.Left;
+					else
+						return UITextAlignment.Natural;
 			}
 		}
 	}
diff --git a/Xamarin.Forms.Platform.iOS/Renderers/DatePickerRenderer.cs b/Xamarin.Forms.Platform.iOS/Renderers/DatePickerRenderer.cs
index 39e7ab77fbb..61d51ac3d90 100644
--- a/Xamarin.Forms.Platform.iOS/Renderers/DatePickerRenderer.cs
+++ b/Xamarin.Forms.Platform.iOS/Renderers/DatePickerRenderer.cs
@@ -63,6 +63,7 @@ protected override void OnElementChanged(ElementChangedEventArgs<DatePicker> e)
 			UpdateMaximumDate();
 			UpdateMinimumDate();
 			UpdateTextColor();
+			UpdateFlowDirection();
 		}
 
 		protected override void OnElementPropertyChanged(object sender, PropertyChangedEventArgs e)
@@ -77,6 +78,8 @@ protected override void OnElementPropertyChanged(object sender, PropertyChangedE
 				UpdateMaximumDate();
 			else if (e.PropertyName == DatePicker.TextColorProperty.PropertyName || e.PropertyName == VisualElement.IsEnabledProperty.PropertyName)
 				UpdateTextColor();
+			else if (e.PropertyName == VisualElement.FlowDirectionProperty.PropertyName)
+				UpdateFlowDirection();
 		}
 
 		void HandleValueChanged(object sender, EventArgs e)
@@ -102,6 +105,11 @@ void UpdateDateFromModel(bool animate)
 			Control.Text = Element.Date.ToString(Element.Format);
 		}
 
+		void UpdateFlowDirection()
+		{
+			(Control as UITextField).UpdateTextAlignment(Element);
+		}
+
 		void UpdateMaximumDate()
 		{
 			_picker.MaximumDate = Element.MaximumDate.ToNSDate();
diff --git a/Xamarin.Forms.Platform.iOS/Renderers/EditorRenderer.cs b/Xamarin.Forms.Platform.iOS/Renderers/EditorRenderer.cs
index b87c0d3c602..5fdceaeec4b 100644
--- a/Xamarin.Forms.Platform.iOS/Renderers/EditorRenderer.cs
+++ b/Xamarin.Forms.Platform.iOS/Renderers/EditorRenderer.cs
@@ -8,9 +8,9 @@ namespace Xamarin.Forms.Platform.iOS
 	public class EditorRenderer : ViewRenderer<Editor, UITextView>
 	{
 		bool _disposed;
-        IEditorController ElementController => Element;
+		IEditorController ElementController => Element;
 
-        protected override void Dispose(bool disposing)
+		protected override void Dispose(bool disposing)
 		{
 			if (_disposed)
 				return;
@@ -51,7 +51,7 @@ protected override void OnElementChanged(ElementChangedEventArgs<Editor> e)
 					var doneButton = new UIBarButtonItem(UIBarButtonSystemItem.Done, (o, a) =>
 					{
 						Control.ResignFirstResponder();
-                        ElementController.SendCompleted();
+						ElementController.SendCompleted();
 					});
 					accessoryView.SetItems(new[] { spacer, doneButton }, false);
 					Control.InputAccessoryView = accessoryView;
@@ -67,6 +67,7 @@ protected override void OnElementChanged(ElementChangedEventArgs<Editor> e)
 			UpdateTextColor();
 			UpdateKeyboard();
 			UpdateEditable();
+			UpdateTextAlignment();
 		}
 
 		protected override void OnElementPropertyChanged(object sender, PropertyChangedEventArgs e)
@@ -87,6 +88,8 @@ protected override void OnElementPropertyChanged(object sender, PropertyChangedE
 				UpdateFont();
 			else if (e.PropertyName == Editor.FontSizeProperty.PropertyName)
 				UpdateFont();
+			else if (e.PropertyName == VisualElement.FlowDirectionProperty.PropertyName)
+				UpdateTextAlignment();
 		}
 
 		void HandleChanged(object sender, EventArgs e)
@@ -135,6 +138,11 @@ void UpdateText()
 				Control.Text = Element.Text;
 		}
 
+		void UpdateTextAlignment()
+		{
+			Control.UpdateTextAlignment(Element);
+		}
+
 		void UpdateTextColor()
 		{
 			var textColor = Element.TextColor;
diff --git a/Xamarin.Forms.Platform.iOS/Renderers/EntryRenderer.cs b/Xamarin.Forms.Platform.iOS/Renderers/EntryRenderer.cs
index c240dd50f86..042f59e038e 100644
--- a/Xamarin.Forms.Platform.iOS/Renderers/EntryRenderer.cs
+++ b/Xamarin.Forms.Platform.iOS/Renderers/EntryRenderer.cs
@@ -114,6 +114,8 @@ protected override void OnElementPropertyChanged(object sender, PropertyChangedE
 			}
 			else if (e.PropertyName == PlatformConfiguration.iOSSpecific.Entry.AdjustsFontSizeToFitWidthProperty.PropertyName)
 				UpdateAdjustsFontSizeToFitWidth();
+			else if (e.PropertyName == VisualElement.FlowDirectionProperty.PropertyName)
+				UpdateAlignment();
 
 			base.OnElementPropertyChanged(sender, e);
 		}
@@ -148,7 +150,7 @@ protected virtual bool OnShouldReturn(UITextField view)
 
 		void UpdateAlignment()
 		{
-			Control.TextAlignment = Element.HorizontalTextAlignment.ToNativeTextAlignment();
+			Control.TextAlignment = Element.HorizontalTextAlignment.ToNativeTextAlignment(((IVisualElementController)Element).EffectiveFlowDirection);
 		}
 
 		void UpdateColor()
diff --git a/Xamarin.Forms.Platform.iOS/Renderers/LabelRenderer.cs b/Xamarin.Forms.Platform.iOS/Renderers/LabelRenderer.cs
index 5f1157fd7f5..50eb46140c7 100644
--- a/Xamarin.Forms.Platform.iOS/Renderers/LabelRenderer.cs
+++ b/Xamarin.Forms.Platform.iOS/Renderers/LabelRenderer.cs
@@ -152,6 +152,8 @@ protected override void OnElementPropertyChanged(object sender, PropertyChangedE
 				UpdateText();
 			else if (e.PropertyName == Label.LineBreakModeProperty.PropertyName)
 				UpdateLineBreakMode();
+			else if (e.PropertyName == VisualElement.FlowDirectionProperty.PropertyName)
+				UpdateAlignment();
 		}
 
 #if __MOBILE__
@@ -190,9 +192,9 @@ protected override void SetBackgroundColor(Color color)
 		void UpdateAlignment()
 		{
 #if __MOBILE__
-			Control.TextAlignment = Element.HorizontalTextAlignment.ToNativeTextAlignment();
+			Control.TextAlignment = Element.HorizontalTextAlignment.ToNativeTextAlignment(((IVisualElementController)Element).EffectiveFlowDirection);
 #else
-			Control.Alignment = Element.HorizontalTextAlignment.ToNativeTextAlignment();
+			Control.Alignment = Element.HorizontalTextAlignment.ToNativeTextAlignment(((IVisualElementController)Element).EffectiveFlowDirection);
 #endif
 		}
 
diff --git a/Xamarin.Forms.Platform.iOS/Renderers/PhoneMasterDetailRenderer.cs b/Xamarin.Forms.Platform.iOS/Renderers/PhoneMasterDetailRenderer.cs
index 12d54fad426..79a650a6109 100644
--- a/Xamarin.Forms.Platform.iOS/Renderers/PhoneMasterDetailRenderer.cs
+++ b/Xamarin.Forms.Platform.iOS/Renderers/PhoneMasterDetailRenderer.cs
@@ -2,6 +2,7 @@
 using System.ComponentModel;
 using System.Linq;
 using UIKit;
+using Xamarin.Forms.Internals;
 using Xamarin.Forms.PlatformConfiguration.iOSSpecific;
 using PointF = CoreGraphics.CGPoint;
 
@@ -25,6 +26,7 @@ public class PhoneMasterDetailRenderer : UIViewController, IVisualElementRendere
 		VisualElementTracker _tracker;
 
 		Page Page => Element as Page;
+		
 
 		public PhoneMasterDetailRenderer()
 		{
@@ -241,12 +243,23 @@ void LayoutChildren(bool animated)
 			var masterFrame = frame;
 			masterFrame.Width = (int)(Math.Min(masterFrame.Width, masterFrame.Height) * 0.8);
 
+			var isRTL = (Element as IVisualElementController)?.EffectiveFlowDirection.IsRightToLeft() == true;
+			if (isRTL)
+			{
+				masterFrame.X = (int)(masterFrame.Width * .25);
+			}
+
 			_masterController.View.Frame = masterFrame;
 
 			var target = frame;
 			if (Presented)
 				target.X += masterFrame.Width;
 
+			if (isRTL)
+			{
+				target.X = target.X * -1;
+			}
+
 			if (animated)
 			{
 				UIView.BeginAnimations("Flyout");
@@ -259,7 +272,7 @@ void LayoutChildren(bool animated)
 			else
 				_detailController.View.Frame = target;
 
-			MasterDetailPage.MasterBounds = new Rectangle(0, 0, masterFrame.Width, masterFrame.Height);
+			MasterDetailPage.MasterBounds = new Rectangle(masterFrame.X, 0, masterFrame.Width, masterFrame.Height);
 			MasterDetailPage.DetailBounds = new Rectangle(0, 0, frame.Width, frame.Height);
 
 			if (Presented)
@@ -341,7 +354,7 @@ public override UIViewController ChildViewControllerForStatusBarHidden()
 			else
 				return base.ChildViewControllerForStatusBarHidden();
 		}
-		
+
 		void UpdatePanGesture()
 		{
 			var model = (MasterDetailPage)Element;
@@ -358,10 +371,14 @@ void UpdatePanGesture()
 				return;
 			}
 
-			UITouchEventArgs shouldRecieve = (g, t) => !(t.View is UISlider);
+			UITouchEventArgs shouldReceive = (g, t) => !(t.View is UISlider);
 			var center = new PointF();
 			_panGesture = new UIPanGestureRecognizer(g =>
 			{
+				var isRTL = (Element as IVisualElementController)?.EffectiveFlowDirection.IsRightToLeft() == true;
+
+				int directionModifier = isRTL ? -1 : 1;
+
 				switch (g.State)
 				{
 					case UIGestureRecognizerState.Began:
@@ -370,12 +387,18 @@ void UpdatePanGesture()
 					case UIGestureRecognizerState.Changed:
 						var currentPosition = g.LocationInView(g.View);
 						var motion = currentPosition.X - center.X;
+
+						motion = motion * directionModifier;
+
 						var detailView = _detailController.View;
 						var targetFrame = detailView.Frame;
 						if (Presented)
 							targetFrame.X = (nfloat)Math.Max(0, _masterController.View.Frame.Width + Math.Min(0, motion));
 						else
 							targetFrame.X = (nfloat)Math.Min(_masterController.View.Frame.Width, Math.Max(0, motion));
+
+						targetFrame.X = targetFrame.X * directionModifier;
+
 						detailView.Frame = targetFrame;
 						break;
 					case UIGestureRecognizerState.Ended:
@@ -383,14 +406,14 @@ void UpdatePanGesture()
 						var masterFrame = _masterController.View.Frame;
 						if (Presented)
 						{
-							if (detailFrame.X < masterFrame.Width * .75)
+							if (detailFrame.X * directionModifier < masterFrame.Width * .75)
 								Presented = false;
 							else
 								LayoutChildren(true);
 						}
 						else
 						{
-							if (detailFrame.X > masterFrame.Width * .25)
+							if (detailFrame.X * directionModifier > masterFrame.Width * .25)
 								Presented = true;
 							else
 								LayoutChildren(true);
@@ -398,7 +421,7 @@ void UpdatePanGesture()
 						break;
 				}
 			});
-			_panGesture.ShouldReceiveTouch = shouldRecieve;
+			_panGesture.ShouldReceiveTouch = shouldReceive;
 			_panGesture.MaximumNumberOfTouches = 2;
 			View.AddGestureRecognizer(_panGesture);
 		}
diff --git a/Xamarin.Forms.Platform.iOS/Renderers/SearchBarRenderer.cs b/Xamarin.Forms.Platform.iOS/Renderers/SearchBarRenderer.cs
index a38aeeebf0b..7a8f09ca184 100644
--- a/Xamarin.Forms.Platform.iOS/Renderers/SearchBarRenderer.cs
+++ b/Xamarin.Forms.Platform.iOS/Renderers/SearchBarRenderer.cs
@@ -96,6 +96,8 @@ protected override void OnElementPropertyChanged(object sender, PropertyChangedE
 				UpdateFont();
 			else if (e.PropertyName == SearchBar.HorizontalTextAlignmentProperty.PropertyName)
 				UpdateAlignment();
+			else if (e.PropertyName == VisualElement.FlowDirectionProperty.PropertyName)
+				UpdateAlignment();
 		}
 
 		protected override void SetBackgroundColor(Color color)
@@ -161,7 +163,7 @@ void UpdateAlignment()
 			if (_textField == null)
 				return;
 
-			_textField.TextAlignment = Element.HorizontalTextAlignment.ToNativeTextAlignment();
+			_textField.TextAlignment = Element.HorizontalTextAlignment.ToNativeTextAlignment(((IVisualElementController)Element).EffectiveFlowDirection);
 		}
 
 		void UpdateCancelButton()
diff --git a/Xamarin.Forms.Platform.iOS/Renderers/TabletMasterDetailRenderer.cs b/Xamarin.Forms.Platform.iOS/Renderers/TabletMasterDetailRenderer.cs
index 6456c16d3ab..4f707dee945 100644
--- a/Xamarin.Forms.Platform.iOS/Renderers/TabletMasterDetailRenderer.cs
+++ b/Xamarin.Forms.Platform.iOS/Renderers/TabletMasterDetailRenderer.cs
@@ -1,7 +1,6 @@
 using System;
 using System.ComponentModel;
 using UIKit;
-using Xamarin.Forms.PlatformConfiguration.iOSSpecific;
 
 namespace Xamarin.Forms.Platform.iOS
 {
@@ -46,7 +45,7 @@ public class TabletMasterDetailRenderer : UISplitViewController, IVisualElementR
 		bool _disposed;
 		EventTracker _events;
 		InnerDelegate _innerDelegate;
-
+		nfloat _masterWidth = 0;
 		EventedViewController _masterController;
 
 		MasterDetailPage _masterDetailPage;
@@ -184,8 +183,10 @@ public override void ViewDidLayoutSubviews()
 			var detailsBounds = _detailController.View.Frame;
 			var masterBounds = _masterController.View.Frame;
 
+			_masterWidth = (nfloat)Math.Max(_masterWidth, masterBounds.Width);
+
 			if (!masterBounds.IsEmpty)
-				MasterDetailPage.MasterBounds = new Rectangle(0, 0, masterBounds.Width, masterBounds.Height);
+				MasterDetailPage.MasterBounds = new Rectangle(_masterWidth, 0, _masterWidth, masterBounds.Height);
 
 			if (!detailsBounds.IsEmpty)
 				MasterDetailPage.DetailBounds = new Rectangle(0, 0, detailsBounds.Width, detailsBounds.Height);
@@ -195,6 +196,7 @@ public override void ViewDidLoad()
 		{
 			base.ViewDidLoad();
 			UpdateBackground();
+			UpdateFlowDirection();
 			_tracker = new VisualElementTracker(this);
 			_events = new EventTracker(this);
 			_events.LoadEvents(NativeView);
@@ -249,6 +251,8 @@ protected virtual void OnElementChanged(VisualElementChangedEventArgs e)
 			var changed = ElementChanged;
 			if (changed != null)
 				changed(this, e);
+
+			_masterWidth = 0;
 		}
 
 		void ClearControllers()
@@ -283,6 +287,8 @@ void HandlePropertyChanged(object sender, PropertyChangedEventArgs e)
 				ToggleMaster();
 			else if (e.PropertyName == Xamarin.Forms.MasterDetailPage.IsGestureEnabledProperty.PropertyName)
 				base.PresentsWithGesture = this.MasterDetailPage.IsGestureEnabled;
+			else if (e.PropertyName == VisualElement.FlowDirectionProperty.PropertyName)
+				UpdateFlowDirection();
 			MessagingCenter.Send<IVisualElementRenderer>(this, NavigationRenderer.UpdateToolbarButtons);
 		}
 
@@ -346,6 +352,11 @@ void UpdateControllers()
 			_detailController.AddChildViewController(detail);
 		}
 
+		void UpdateFlowDirection()
+		{
+			NativeView.UpdateFlowDirection(Element);
+		}
+
 		class InnerDelegate : UISplitViewControllerDelegate
 		{
 			readonly MasterBehavior _masterPresentedDefaultState;
diff --git a/Xamarin.Forms.Platform.iOS/Renderers/TimePickerRenderer.cs b/Xamarin.Forms.Platform.iOS/Renderers/TimePickerRenderer.cs
index bfb96d81bb3..a814002c3b3 100644
--- a/Xamarin.Forms.Platform.iOS/Renderers/TimePickerRenderer.cs
+++ b/Xamarin.Forms.Platform.iOS/Renderers/TimePickerRenderer.cs
@@ -75,6 +75,7 @@ protected override void OnElementChanged(ElementChangedEventArgs<TimePicker> e)
 
 				UpdateTime();
 				UpdateTextColor();
+				UpdateFlowDirection();
 			}
 
 			base.OnElementChanged(e);
@@ -89,6 +90,9 @@ protected override void OnElementPropertyChanged(object sender, PropertyChangedE
 
 			if (e.PropertyName == TimePicker.TextColorProperty.PropertyName || e.PropertyName == VisualElement.IsEnabledProperty.PropertyName)
 				UpdateTextColor();
+
+			if (e.PropertyName == VisualElement.FlowDirectionProperty.PropertyName)
+				UpdateFlowDirection();
 		}
 
 		void OnEnded(object sender, EventArgs eventArgs)
@@ -106,6 +110,11 @@ void OnValueChanged(object sender, EventArgs e)
 			ElementController.SetValueFromRenderer(TimePicker.TimeProperty, _picker.Date.ToDateTime() - new DateTime(1, 1, 1));
 		}
 
+		void UpdateFlowDirection()
+		{
+			(Control as UITextField).UpdateTextAlignment(Element);
+		}
+
 		void UpdateTextColor()
 		{
 			var textColor = Element.TextColor;
diff --git a/Xamarin.Forms.Platform.iOS/ViewRenderer.cs b/Xamarin.Forms.Platform.iOS/ViewRenderer.cs
index 13b11e6d99d..5ea6a94fe34 100644
--- a/Xamarin.Forms.Platform.iOS/ViewRenderer.cs
+++ b/Xamarin.Forms.Platform.iOS/ViewRenderer.cs
@@ -5,10 +5,9 @@
 using SizeF = CoreGraphics.CGSize;
 
 #if __MOBILE__
-using UIKit;
-using NativeView = UIKit.UIView;
 using NativeColor = UIKit.UIColor;
 using NativeControl = UIKit.UIControl;
+using NativeView = UIKit.UIView;
 
 namespace Xamarin.Forms.Platform.iOS
 #else
@@ -96,6 +95,7 @@ protected override void OnElementChanged(ElementChangedEventArgs<TView> e)
 			}
 
 			UpdateIsEnabled();
+			UpdateFlowDirection();
 		}
 
 		protected override void OnElementPropertyChanged(object sender, PropertyChangedEventArgs e)
@@ -106,6 +106,8 @@ protected override void OnElementPropertyChanged(object sender, PropertyChangedE
 					UpdateIsEnabled();
 				else if (e.PropertyName == VisualElement.BackgroundColorProperty.PropertyName)
 					SetBackgroundColor(Element.BackgroundColor);
+				else if (e.PropertyName == VisualElement.FlowDirectionProperty.PropertyName)
+					UpdateFlowDirection();
 			}
 
 			base.OnElementPropertyChanged(sender, e);
@@ -209,6 +211,8 @@ protected void SetNativeControl(TNativeView uiview)
 
 			UpdateIsEnabled();
 
+			UpdateFlowDirection();
+
 			AddSubview(uiview);
 		}
 
@@ -230,6 +234,11 @@ void UpdateIsEnabled()
 			uiControl.Enabled = Element.IsEnabled;
 		}
 
+		void UpdateFlowDirection()
+		{
+			Control.UpdateFlowDirection(Element);
+		}
+
 		void ViewOnFocusChangeRequested(object sender, VisualElement.FocusRequestArgs focusRequestArgs)
 		{
 			if (Control == null)
diff --git a/Xamarin.Forms.Platform.iOS/Xamarin.Forms.Platform.iOS.csproj b/Xamarin.Forms.Platform.iOS/Xamarin.Forms.Platform.iOS.csproj
index 8fd3ae7d3a0..638140ed96f 100644
--- a/Xamarin.Forms.Platform.iOS/Xamarin.Forms.Platform.iOS.csproj
+++ b/Xamarin.Forms.Platform.iOS/Xamarin.Forms.Platform.iOS.csproj
@@ -120,6 +120,7 @@
     <Compile Include="ExportImageSourceHandlerAttribute.cs" />
     <Compile Include="ExportRendererAttribute.cs" />
     <Compile Include="Extensions\ArrayExtensions.cs" />
+    <Compile Include="Extensions\FlowDirectionExtensions.cs" />
     <Compile Include="Extensions\PlatformConfigurationExtensions.cs" />
     <Compile Include="Flags.cs" />
     <Compile Include="NativeViewWrapper.cs" />
@@ -195,4 +196,4 @@
       <Link>Properties\GlobalAssemblyInfo.cs</Link>
     </Compile>
   </ItemGroup>
-</Project>
+</Project>
\ No newline at end of file
diff --git a/docs/Xamarin.Forms.Core/Xamarin.Forms/Device.xml b/docs/Xamarin.Forms.Core/Xamarin.Forms/Device.xml
index 7cb9d5f4cc1..085af56fd98 100644
--- a/docs/Xamarin.Forms.Core/Xamarin.Forms/Device.xml
+++ b/docs/Xamarin.Forms.Core/Xamarin.Forms/Device.xml
@@ -92,6 +92,22 @@ Device.BeginInvokeOnMainThread (() => {
         <remarks>To be added.</remarks>
       </Docs>
     </Member>
+    <Member MemberName="FlowDirection">
+      <MemberSignature Language="C#" Value="public static Xamarin.Forms.FlowDirection FlowDirection { get; }" />
+      <MemberSignature Language="ILAsm" Value=".property valuetype Xamarin.Forms.FlowDirection FlowDirection" />
+      <MemberType>Property</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>2.0.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>Xamarin.Forms.FlowDirection</ReturnType>
+      </ReturnValue>
+      <Docs>
+        <summary>To be added.</summary>
+        <value>To be added.</value>
+        <remarks>To be added.</remarks>
+      </Docs>
+    </Member>
     <Member MemberName="GetAssemblies">
       <MemberSignature Language="C#" Value="public static System.Reflection.Assembly[] GetAssemblies ();" />
       <MemberSignature Language="ILAsm" Value=".method public static hidebysig class System.Reflection.Assembly[] GetAssemblies() cil managed" />
@@ -513,6 +529,30 @@ button.HeightRequest = Device.OnPlatform (20,30,30);
         <remarks>To be added.</remarks>
       </Docs>
     </Member>
+    <Member MemberName="SetFlowDirection">
+      <MemberSignature Language="C#" Value="public static void SetFlowDirection (Xamarin.Forms.FlowDirection value);" />
+      <MemberSignature Language="ILAsm" Value=".method public static hidebysig void SetFlowDirection(valuetype Xamarin.Forms.FlowDirection value) cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>2.0.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <Attributes>
+        <Attribute>
+          <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+        </Attribute>
+      </Attributes>
+      <ReturnValue>
+        <ReturnType>System.Void</ReturnType>
+      </ReturnValue>
+      <Parameters>
+        <Parameter Name="value" Type="Xamarin.Forms.FlowDirection" />
+      </Parameters>
+      <Docs>
+        <param name="value">To be added.</param>
+        <summary>To be added.</summary>
+        <remarks>To be added.</remarks>
+      </Docs>
+    </Member>
     <Member MemberName="SetIdiom">
       <MemberSignature Language="C#" Value="public static void SetIdiom (Xamarin.Forms.TargetIdiom value);" />
       <MemberSignature Language="ILAsm" Value=".method public static hidebysig void SetIdiom(valuetype Xamarin.Forms.TargetIdiom value) cil managed" />
diff --git a/docs/Xamarin.Forms.Core/Xamarin.Forms/EffectiveFlowDirection.xml b/docs/Xamarin.Forms.Core/Xamarin.Forms/EffectiveFlowDirection.xml
new file mode 100644
index 00000000000..8a336a0bca1
--- /dev/null
+++ b/docs/Xamarin.Forms.Core/Xamarin.Forms/EffectiveFlowDirection.xml
@@ -0,0 +1,50 @@
+<Type Name="EffectiveFlowDirection" FullName="Xamarin.Forms.EffectiveFlowDirection">
+  <TypeSignature Language="C#" Value="public enum EffectiveFlowDirection" />
+  <TypeSignature Language="ILAsm" Value=".class public auto ansi sealed EffectiveFlowDirection extends System.Enum" />
+  <AssemblyInfo>
+    <AssemblyName>Xamarin.Forms.Core</AssemblyName>
+    <AssemblyVersion>2.0.0.0</AssemblyVersion>
+  </AssemblyInfo>
+  <Base>
+    <BaseTypeName>System.Enum</BaseTypeName>
+  </Base>
+  <Attributes>
+    <Attribute>
+      <AttributeName>System.Flags</AttributeName>
+    </Attribute>
+  </Attributes>
+  <Docs>
+    <summary>To be added.</summary>
+    <remarks>To be added.</remarks>
+  </Docs>
+  <Members>
+    <Member MemberName="Explicit">
+      <MemberSignature Language="C#" Value="Explicit" />
+      <MemberSignature Language="ILAsm" Value=".field public static literal valuetype Xamarin.Forms.EffectiveFlowDirection Explicit = int32(2)" />
+      <MemberType>Field</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>2.0.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>Xamarin.Forms.EffectiveFlowDirection</ReturnType>
+      </ReturnValue>
+      <Docs>
+        <summary>To be added.</summary>
+      </Docs>
+    </Member>
+    <Member MemberName="RightToLeft">
+      <MemberSignature Language="C#" Value="RightToLeft" />
+      <MemberSignature Language="ILAsm" Value=".field public static literal valuetype Xamarin.Forms.EffectiveFlowDirection RightToLeft = int32(1)" />
+      <MemberType>Field</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>2.0.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>Xamarin.Forms.EffectiveFlowDirection</ReturnType>
+      </ReturnValue>
+      <Docs>
+        <summary>To be added.</summary>
+      </Docs>
+    </Member>
+  </Members>
+</Type>
diff --git a/docs/Xamarin.Forms.Core/Xamarin.Forms/EffectiveFlowDirectionExtensions.xml b/docs/Xamarin.Forms.Core/Xamarin.Forms/EffectiveFlowDirectionExtensions.xml
new file mode 100644
index 00000000000..673717e1883
--- /dev/null
+++ b/docs/Xamarin.Forms.Core/Xamarin.Forms/EffectiveFlowDirectionExtensions.xml
@@ -0,0 +1,103 @@
+<Type Name="EffectiveFlowDirectionExtensions" FullName="Xamarin.Forms.EffectiveFlowDirectionExtensions">
+  <TypeSignature Language="C#" Value="public static class EffectiveFlowDirectionExtensions" />
+  <TypeSignature Language="ILAsm" Value=".class public auto ansi abstract sealed beforefieldinit EffectiveFlowDirectionExtensions extends System.Object" />
+  <AssemblyInfo>
+    <AssemblyName>Xamarin.Forms.Core</AssemblyName>
+    <AssemblyVersion>2.0.0.0</AssemblyVersion>
+  </AssemblyInfo>
+  <Base>
+    <BaseTypeName>System.Object</BaseTypeName>
+  </Base>
+  <Interfaces />
+  <Attributes>
+    <Attribute>
+      <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)</AttributeName>
+    </Attribute>
+  </Attributes>
+  <Docs>
+    <summary>To be added.</summary>
+    <remarks>To be added.</remarks>
+  </Docs>
+  <Members>
+    <Member MemberName="IsExplicit">
+      <MemberSignature Language="C#" Value="public static bool IsExplicit (this Xamarin.Forms.EffectiveFlowDirection self);" />
+      <MemberSignature Language="ILAsm" Value=".method public static hidebysig bool IsExplicit(valuetype Xamarin.Forms.EffectiveFlowDirection self) cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>2.0.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>System.Boolean</ReturnType>
+      </ReturnValue>
+      <Parameters>
+        <Parameter Name="self" Type="Xamarin.Forms.EffectiveFlowDirection" RefType="this" />
+      </Parameters>
+      <Docs>
+        <param name="self">To be added.</param>
+        <summary>To be added.</summary>
+        <returns>To be added.</returns>
+        <remarks>To be added.</remarks>
+      </Docs>
+    </Member>
+    <Member MemberName="IsImplicit">
+      <MemberSignature Language="C#" Value="public static bool IsImplicit (this Xamarin.Forms.EffectiveFlowDirection self);" />
+      <MemberSignature Language="ILAsm" Value=".method public static hidebysig bool IsImplicit(valuetype Xamarin.Forms.EffectiveFlowDirection self) cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>2.0.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>System.Boolean</ReturnType>
+      </ReturnValue>
+      <Parameters>
+        <Parameter Name="self" Type="Xamarin.Forms.EffectiveFlowDirection" RefType="this" />
+      </Parameters>
+      <Docs>
+        <param name="self">To be added.</param>
+        <summary>To be added.</summary>
+        <returns>To be added.</returns>
+        <remarks>To be added.</remarks>
+      </Docs>
+    </Member>
+    <Member MemberName="IsLeftToRight">
+      <MemberSignature Language="C#" Value="public static bool IsLeftToRight (this Xamarin.Forms.EffectiveFlowDirection self);" />
+      <MemberSignature Language="ILAsm" Value=".method public static hidebysig bool IsLeftToRight(valuetype Xamarin.Forms.EffectiveFlowDirection self) cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>2.0.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>System.Boolean</ReturnType>
+      </ReturnValue>
+      <Parameters>
+        <Parameter Name="self" Type="Xamarin.Forms.EffectiveFlowDirection" RefType="this" />
+      </Parameters>
+      <Docs>
+        <param name="self">To be added.</param>
+        <summary>To be added.</summary>
+        <returns>To be added.</returns>
+        <remarks>To be added.</remarks>
+      </Docs>
+    </Member>
+    <Member MemberName="IsRightToLeft">
+      <MemberSignature Language="C#" Value="public static bool IsRightToLeft (this Xamarin.Forms.EffectiveFlowDirection self);" />
+      <MemberSignature Language="ILAsm" Value=".method public static hidebysig bool IsRightToLeft(valuetype Xamarin.Forms.EffectiveFlowDirection self) cil managed" />
+      <MemberType>Method</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>2.0.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>System.Boolean</ReturnType>
+      </ReturnValue>
+      <Parameters>
+        <Parameter Name="self" Type="Xamarin.Forms.EffectiveFlowDirection" RefType="this" />
+      </Parameters>
+      <Docs>
+        <param name="self">To be added.</param>
+        <summary>To be added.</summary>
+        <returns>To be added.</returns>
+        <remarks>To be added.</remarks>
+      </Docs>
+    </Member>
+  </Members>
+</Type>
diff --git a/docs/Xamarin.Forms.Core/Xamarin.Forms/FlowDirection.xml b/docs/Xamarin.Forms.Core/Xamarin.Forms/FlowDirection.xml
new file mode 100644
index 00000000000..9350208cc7f
--- /dev/null
+++ b/docs/Xamarin.Forms.Core/Xamarin.Forms/FlowDirection.xml
@@ -0,0 +1,59 @@
+<Type Name="FlowDirection" FullName="Xamarin.Forms.FlowDirection">
+  <TypeSignature Language="C#" Value="public enum FlowDirection" />
+  <TypeSignature Language="ILAsm" Value=".class public auto ansi sealed FlowDirection extends System.Enum" />
+  <AssemblyInfo>
+    <AssemblyName>Xamarin.Forms.Core</AssemblyName>
+    <AssemblyVersion>2.0.0.0</AssemblyVersion>
+  </AssemblyInfo>
+  <Base>
+    <BaseTypeName>System.Enum</BaseTypeName>
+  </Base>
+  <Docs>
+    <summary>To be added.</summary>
+    <remarks>To be added.</remarks>
+  </Docs>
+  <Members>
+    <Member MemberName="LeftToRight">
+      <MemberSignature Language="C#" Value="LeftToRight" />
+      <MemberSignature Language="ILAsm" Value=".field public static literal valuetype Xamarin.Forms.FlowDirection LeftToRight = int32(1)" />
+      <MemberType>Field</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>2.0.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>Xamarin.Forms.FlowDirection</ReturnType>
+      </ReturnValue>
+      <Docs>
+        <summary>To be added.</summary>
+      </Docs>
+    </Member>
+    <Member MemberName="MatchParent">
+      <MemberSignature Language="C#" Value="MatchParent" />
+      <MemberSignature Language="ILAsm" Value=".field public static literal valuetype Xamarin.Forms.FlowDirection MatchParent = int32(0)" />
+      <MemberType>Field</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>2.0.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>Xamarin.Forms.FlowDirection</ReturnType>
+      </ReturnValue>
+      <Docs>
+        <summary>To be added.</summary>
+      </Docs>
+    </Member>
+    <Member MemberName="RightToLeft">
+      <MemberSignature Language="C#" Value="RightToLeft" />
+      <MemberSignature Language="ILAsm" Value=".field public static literal valuetype Xamarin.Forms.FlowDirection RightToLeft = int32(2)" />
+      <MemberType>Field</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>2.0.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>Xamarin.Forms.FlowDirection</ReturnType>
+      </ReturnValue>
+      <Docs>
+        <summary>To be added.</summary>
+      </Docs>
+    </Member>
+  </Members>
+</Type>
diff --git a/docs/Xamarin.Forms.Core/Xamarin.Forms/IVisualElementController.xml b/docs/Xamarin.Forms.Core/Xamarin.Forms/IVisualElementController.xml
index 43b8589fe96..c5ef853ed7e 100644
--- a/docs/Xamarin.Forms.Core/Xamarin.Forms/IVisualElementController.xml
+++ b/docs/Xamarin.Forms.Core/Xamarin.Forms/IVisualElementController.xml
@@ -65,6 +65,22 @@
         <remarks>To be added.</remarks>
       </Docs>
     </Member>
+    <Member MemberName="EffectiveFlowDirection">
+      <MemberSignature Language="C#" Value="public Xamarin.Forms.EffectiveFlowDirection EffectiveFlowDirection { get; }" />
+      <MemberSignature Language="ILAsm" Value=".property instance valuetype Xamarin.Forms.EffectiveFlowDirection EffectiveFlowDirection" />
+      <MemberType>Property</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>2.0.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>Xamarin.Forms.EffectiveFlowDirection</ReturnType>
+      </ReturnValue>
+      <Docs>
+        <summary>To be added.</summary>
+        <value>To be added.</value>
+        <remarks>To be added.</remarks>
+      </Docs>
+    </Member>
     <Member MemberName="FocusChangeRequested">
       <MemberSignature Language="C#" Value="public event EventHandler&lt;Xamarin.Forms.VisualElement.FocusRequestArgs&gt; FocusChangeRequested;" />
       <MemberSignature Language="ILAsm" Value=".event class System.EventHandler`1&lt;class Xamarin.Forms.VisualElement/FocusRequestArgs&gt; FocusChangeRequested" />
diff --git a/docs/Xamarin.Forms.Core/Xamarin.Forms/VisualElement.xml b/docs/Xamarin.Forms.Core/Xamarin.Forms/VisualElement.xml
index 4e91f3672e6..64b4eae7cf6 100644
--- a/docs/Xamarin.Forms.Core/Xamarin.Forms/VisualElement.xml
+++ b/docs/Xamarin.Forms.Core/Xamarin.Forms/VisualElement.xml
@@ -352,6 +352,37 @@
         <remarks>To be added.</remarks>
       </Docs>
     </Member>
+    <Member MemberName="FlowDirection">
+      <MemberSignature Language="C#" Value="public Xamarin.Forms.FlowDirection FlowDirection { get; set; }" />
+      <MemberSignature Language="ILAsm" Value=".property instance valuetype Xamarin.Forms.FlowDirection FlowDirection" />
+      <MemberType>Property</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>2.0.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>Xamarin.Forms.FlowDirection</ReturnType>
+      </ReturnValue>
+      <Docs>
+        <summary>To be added.</summary>
+        <value>To be added.</value>
+        <remarks>To be added.</remarks>
+      </Docs>
+    </Member>
+    <Member MemberName="FlowDirectionProperty">
+      <MemberSignature Language="C#" Value="public static readonly Xamarin.Forms.BindableProperty FlowDirectionProperty;" />
+      <MemberSignature Language="ILAsm" Value=".field public static initonly class Xamarin.Forms.BindableProperty FlowDirectionProperty" />
+      <MemberType>Field</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>2.0.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>Xamarin.Forms.BindableProperty</ReturnType>
+      </ReturnValue>
+      <Docs>
+        <summary>To be added.</summary>
+        <remarks>To be added.</remarks>
+      </Docs>
+    </Member>
     <Member MemberName="Focus">
       <MemberSignature Language="C#" Value="public bool Focus ();" />
       <MemberSignature Language="ILAsm" Value=".method public hidebysig instance bool Focus() cil managed" />
@@ -2062,6 +2093,22 @@
         <remarks>The x value of an element is set during the Layout phase.</remarks>
       </Docs>
     </Member>
+    <Member MemberName="Xamarin.Forms.IVisualElementController.EffectiveFlowDirection">
+      <MemberSignature Language="C#" Value="Xamarin.Forms.EffectiveFlowDirection Xamarin.Forms.IVisualElementController.EffectiveFlowDirection { get; }" />
+      <MemberSignature Language="ILAsm" Value=".property instance valuetype Xamarin.Forms.EffectiveFlowDirection Xamarin.Forms.IVisualElementController.EffectiveFlowDirection" />
+      <MemberType>Property</MemberType>
+      <AssemblyInfo>
+        <AssemblyVersion>2.0.0.0</AssemblyVersion>
+      </AssemblyInfo>
+      <ReturnValue>
+        <ReturnType>Xamarin.Forms.EffectiveFlowDirection</ReturnType>
+      </ReturnValue>
+      <Docs>
+        <summary>To be added.</summary>
+        <value>To be added.</value>
+        <remarks>To be added.</remarks>
+      </Docs>
+    </Member>
     <Member MemberName="Xamarin.Forms.IVisualElementController.InvalidateMeasure">
       <MemberSignature Language="C#" Value="void IVisualElementController.InvalidateMeasure (Xamarin.Forms.Internals.InvalidationTrigger trigger);" />
       <MemberSignature Language="ILAsm" Value=".method hidebysig newslot virtual instance void Xamarin.Forms.IVisualElementController.InvalidateMeasure(valuetype Xamarin.Forms.Internals.InvalidationTrigger trigger) cil managed" />
diff --git a/docs/Xamarin.Forms.Core/index.xml b/docs/Xamarin.Forms.Core/index.xml
index 1804442e6c0..fbb0486b8ae 100644
--- a/docs/Xamarin.Forms.Core/index.xml
+++ b/docs/Xamarin.Forms.Core/index.xml
@@ -213,6 +213,8 @@
       <Type Name="Easing" Kind="Class" />
       <Type Name="Editor" Kind="Class" />
       <Type Name="Effect" Kind="Class" />
+      <Type Name="EffectiveFlowDirection" Kind="Enumeration" />
+      <Type Name="EffectiveFlowDirectionExtensions" Kind="Class" />
       <Type Name="Element" Kind="Class" />
       <Type Name="ElementEventArgs" Kind="Class" />
       <Type Name="ElementTemplate" Kind="Class" />
@@ -222,6 +224,7 @@
       <Type Name="ExportEffectAttribute" Kind="Class" />
       <Type Name="FileImageSource" Kind="Class" />
       <Type Name="FileImageSourceConverter" Kind="Class" />
+      <Type Name="FlowDirection" Kind="Enumeration" />
       <Type Name="FocusEventArgs" Kind="Class" />
       <Type Name="Font" Kind="Structure" />
       <Type Name="FontAttributes" Kind="Enumeration" />
@@ -855,6 +858,90 @@
         <Link Type="Xamarin.Forms.BindableObjectExtensions" Member="M:Xamarin.Forms.BindableObjectExtensions.SetBinding``1(Xamarin.Forms.BindableObject,Xamarin.Forms.BindableProperty,System.Linq.Expressions.Expression{System.Func{``0,System.Object}},Xamarin.Forms.BindingMode,Xamarin.Forms.IValueConverter,System.String)" />
       </Member>
     </ExtensionMethod>
+    <ExtensionMethod>
+      <Targets>
+        <Target Type="T:Xamarin.Forms.EffectiveFlowDirection" />
+      </Targets>
+      <Member MemberName="IsExplicit">
+        <MemberSignature Language="C#" Value="public static bool IsExplicit (this Xamarin.Forms.EffectiveFlowDirection self);" />
+        <MemberSignature Language="ILAsm" Value=".method public static hidebysig bool IsExplicit(valuetype Xamarin.Forms.EffectiveFlowDirection self) cil managed" />
+        <MemberType>ExtensionMethod</MemberType>
+        <ReturnValue>
+          <ReturnType>System.Boolean</ReturnType>
+        </ReturnValue>
+        <Parameters>
+          <Parameter Name="self" Type="Xamarin.Forms.EffectiveFlowDirection" RefType="this" />
+        </Parameters>
+        <Docs>
+          <param name="self">To be added.</param>
+          <summary>To be added.</summary>
+        </Docs>
+        <Link Type="Xamarin.Forms.EffectiveFlowDirectionExtensions" Member="M:Xamarin.Forms.EffectiveFlowDirectionExtensions.IsExplicit(Xamarin.Forms.EffectiveFlowDirection)" />
+      </Member>
+    </ExtensionMethod>
+    <ExtensionMethod>
+      <Targets>
+        <Target Type="T:Xamarin.Forms.EffectiveFlowDirection" />
+      </Targets>
+      <Member MemberName="IsImplicit">
+        <MemberSignature Language="C#" Value="public static bool IsImplicit (this Xamarin.Forms.EffectiveFlowDirection self);" />
+        <MemberSignature Language="ILAsm" Value=".method public static hidebysig bool IsImplicit(valuetype Xamarin.Forms.EffectiveFlowDirection self) cil managed" />
+        <MemberType>ExtensionMethod</MemberType>
+        <ReturnValue>
+          <ReturnType>System.Boolean</ReturnType>
+        </ReturnValue>
+        <Parameters>
+          <Parameter Name="self" Type="Xamarin.Forms.EffectiveFlowDirection" RefType="this" />
+        </Parameters>
+        <Docs>
+          <param name="self">To be added.</param>
+          <summary>To be added.</summary>
+        </Docs>
+        <Link Type="Xamarin.Forms.EffectiveFlowDirectionExtensions" Member="M:Xamarin.Forms.EffectiveFlowDirectionExtensions.IsImplicit(Xamarin.Forms.EffectiveFlowDirection)" />
+      </Member>
+    </ExtensionMethod>
+    <ExtensionMethod>
+      <Targets>
+        <Target Type="T:Xamarin.Forms.EffectiveFlowDirection" />
+      </Targets>
+      <Member MemberName="IsLeftToRight">
+        <MemberSignature Language="C#" Value="public static bool IsLeftToRight (this Xamarin.Forms.EffectiveFlowDirection self);" />
+        <MemberSignature Language="ILAsm" Value=".method public static hidebysig bool IsLeftToRight(valuetype Xamarin.Forms.EffectiveFlowDirection self) cil managed" />
+        <MemberType>ExtensionMethod</MemberType>
+        <ReturnValue>
+          <ReturnType>System.Boolean</ReturnType>
+        </ReturnValue>
+        <Parameters>
+          <Parameter Name="self" Type="Xamarin.Forms.EffectiveFlowDirection" RefType="this" />
+        </Parameters>
+        <Docs>
+          <param name="self">To be added.</param>
+          <summary>To be added.</summary>
+        </Docs>
+        <Link Type="Xamarin.Forms.EffectiveFlowDirectionExtensions" Member="M:Xamarin.Forms.EffectiveFlowDirectionExtensions.IsLeftToRight(Xamarin.Forms.EffectiveFlowDirection)" />
+      </Member>
+    </ExtensionMethod>
+    <ExtensionMethod>
+      <Targets>
+        <Target Type="T:Xamarin.Forms.EffectiveFlowDirection" />
+      </Targets>
+      <Member MemberName="IsRightToLeft">
+        <MemberSignature Language="C#" Value="public static bool IsRightToLeft (this Xamarin.Forms.EffectiveFlowDirection self);" />
+        <MemberSignature Language="ILAsm" Value=".method public static hidebysig bool IsRightToLeft(valuetype Xamarin.Forms.EffectiveFlowDirection self) cil managed" />
+        <MemberType>ExtensionMethod</MemberType>
+        <ReturnValue>
+          <ReturnType>System.Boolean</ReturnType>
+        </ReturnValue>
+        <Parameters>
+          <Parameter Name="self" Type="Xamarin.Forms.EffectiveFlowDirection" RefType="this" />
+        </Parameters>
+        <Docs>
+          <param name="self">To be added.</param>
+          <summary>To be added.</summary>
+        </Docs>
+        <Link Type="Xamarin.Forms.EffectiveFlowDirectionExtensions" Member="M:Xamarin.Forms.EffectiveFlowDirectionExtensions.IsRightToLeft(Xamarin.Forms.EffectiveFlowDirection)" />
+      </Member>
+    </ExtensionMethod>
     <ExtensionMethod>
       <Targets>
         <Target Type="T:Xamarin.Forms.BindableObject" />