diff --git a/samples/ControlCatalog/MainView.xaml b/samples/ControlCatalog/MainView.xaml
index 803ca522548..d049e839be4 100644
--- a/samples/ControlCatalog/MainView.xaml
+++ b/samples/ControlCatalog/MainView.xaml
@@ -6,7 +6,8 @@
              xmlns:models="using:ControlCatalog.Models"
              xmlns:pages="using:ControlCatalog.Pages"
              xmlns:viewModels="using:ControlCatalog.ViewModels"
-             x:DataType="viewModels:MainWindowViewModel">
+             x:DataType="viewModels:MainWindowViewModel"
+             TextScaling.IsEnabled="True">
   <Grid>
     <Grid.Styles>
       <Style Selector="TextBlock.h2">
diff --git a/src/Avalonia.Base/ITextScaler.cs b/src/Avalonia.Base/ITextScaler.cs
new file mode 100644
index 00000000000..624a47d0e22
--- /dev/null
+++ b/src/Avalonia.Base/ITextScaler.cs
@@ -0,0 +1,16 @@
+using System;
+
+namespace Avalonia;
+
+/// <summary>
+/// Represents an object which can algoritmically scale text.
+/// </summary>
+public interface ITextScaler
+{
+    double GetScaledFontSize(Visual target, double baseFontSize);
+
+    /// <summary>
+    /// Raised when the text scaling algorithm has changed. Indicates that all text should be rescaled.
+    /// </summary>
+    event EventHandler<EventArgs>? TextScalingChanged;
+}
diff --git a/src/Avalonia.Base/Platform/DefaultPlatformSettings.cs b/src/Avalonia.Base/Platform/DefaultPlatformSettings.cs
index 5f17627ace3..7888b3c5345 100644
--- a/src/Avalonia.Base/Platform/DefaultPlatformSettings.cs
+++ b/src/Avalonia.Base/Platform/DefaultPlatformSettings.cs
@@ -1,10 +1,8 @@
 using System;
 using Avalonia.Input;
 using Avalonia.Input.Platform;
-using Avalonia.Media;
 using Avalonia.Metadata;
 using Avalonia.Threading;
-using Avalonia.VisualTree;
 
 namespace Avalonia.Platform
 {
@@ -49,10 +47,16 @@ public virtual PlatformColorValues GetColorValues()
 
         public virtual event EventHandler<PlatformColorValues>? ColorValuesChanged;
 
-        protected void OnColorValuesChanged(PlatformColorValues colorValues)
+        protected virtual void OnColorValuesChanged(PlatformColorValues colorValues)
         {
             Dispatcher.UIThread.Send(
                 _ => ColorValuesChanged?.Invoke(this, colorValues));
         }
+
+        public event EventHandler<EventArgs>? TextScalingChanged;
+
+        protected virtual void OnTextScaleChanged() => Dispatcher.UIThread.Send(_ => TextScalingChanged?.Invoke(this, EventArgs.Empty));
+
+        public virtual double GetScaledFontSize(Visual target, double baseFontSize) => baseFontSize;
     }
 }
diff --git a/src/Avalonia.Base/Platform/IPlatformSettings.cs b/src/Avalonia.Base/Platform/IPlatformSettings.cs
index 46980c6d519..077db569dd5 100644
--- a/src/Avalonia.Base/Platform/IPlatformSettings.cs
+++ b/src/Avalonia.Base/Platform/IPlatformSettings.cs
@@ -10,7 +10,7 @@ namespace Avalonia.Platform
     /// Some of these settings might be changed by used globally in the OS in runtime.
     /// </summary>
     [NotClientImplementable]
-    public interface IPlatformSettings
+    public interface IPlatformSettings : ITextScaler
     {
         /// <summary>
         /// The size of the rectangle around the location of a pointer down that a pointer up
@@ -42,7 +42,7 @@ public interface IPlatformSettings
         /// Get a configuration for platform-specific hotkeys in an Avalonia application.
         /// </summary>
         PlatformHotkeyConfiguration HotkeyConfiguration { get; }
-        
+
         /// <summary>
         /// Gets current system color values including dark mode and accent colors.
         /// </summary>
diff --git a/src/Avalonia.Controls/Documents/IInlineHost.cs b/src/Avalonia.Controls/Documents/IInlineHost.cs
index e16da219b4c..167e1867210 100644
--- a/src/Avalonia.Controls/Documents/IInlineHost.cs
+++ b/src/Avalonia.Controls/Documents/IInlineHost.cs
@@ -3,7 +3,7 @@
 
 namespace Avalonia.Controls.Documents
 {
-    internal interface IInlineHost : ILogical
+    internal interface IInlineHost : ILogical, ITextScaleable
     {
         void Invalidate();
 
diff --git a/src/Avalonia.Controls/Documents/Inline.cs b/src/Avalonia.Controls/Documents/Inline.cs
index 4338dc6d536..b2222c9548c 100644
--- a/src/Avalonia.Controls/Documents/Inline.cs
+++ b/src/Avalonia.Controls/Documents/Inline.cs
@@ -81,7 +81,7 @@ protected TextRunProperties CreateTextRunProperties()
 
             return new GenericTextRunProperties(
                 typeface,
-                FontSize,
+                InlineHost is Visual hostVisual ? TextScaling.GetScaledFontSize(hostVisual, FontSize) : FontSize,
                 TextDecorations,
                 Foreground,
                 parentOrSelfBackground,
diff --git a/src/Avalonia.Controls/Documents/TextElement.cs b/src/Avalonia.Controls/Documents/TextElement.cs
index cac8d6f97f2..46fc3f15182 100644
--- a/src/Avalonia.Controls/Documents/TextElement.cs
+++ b/src/Avalonia.Controls/Documents/TextElement.cs
@@ -354,6 +354,12 @@ protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs chang
         {
             base.OnPropertyChanged(change);
 
+            if (change.Property.OwnerType == typeof(TextScaling))
+            {
+                InlineHost?.Invalidate();
+                return;
+            }
+
             switch (change.Property.Name)
             {
                 case nameof(Background):
@@ -363,7 +369,7 @@ protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs chang
                 case nameof(FontWeight):
                 case nameof(FontStretch):
                 case nameof(Foreground):
-                    InlineHost?.Invalidate();
+                InlineHost?.Invalidate();
                     break;
             }
         }
diff --git a/src/Avalonia.Controls/ITextScaleable.cs b/src/Avalonia.Controls/ITextScaleable.cs
new file mode 100644
index 00000000000..7dd5512ae46
--- /dev/null
+++ b/src/Avalonia.Controls/ITextScaleable.cs
@@ -0,0 +1,13 @@
+namespace Avalonia.Controls;
+
+/// <summary>
+/// Represents an object which particpates in <see cref="TextScaling"/>.
+/// </summary>
+/// <seealso cref="ITextScaler"/>
+public interface ITextScaleable
+{
+    /// <summary>
+    /// Called when the active text scaling algorithm for this object changes.
+    /// </summary>
+    void OnTextScalingChanged();
+}
diff --git a/src/Avalonia.Controls/Presenters/TextPresenter.cs b/src/Avalonia.Controls/Presenters/TextPresenter.cs
index 05c74b39e59..ae0a9a665e8 100644
--- a/src/Avalonia.Controls/Presenters/TextPresenter.cs
+++ b/src/Avalonia.Controls/Presenters/TextPresenter.cs
@@ -1,9 +1,7 @@
 using System;
 using System.Collections.Generic;
-using System.Data;
 using Avalonia.Controls.Documents;
 using Avalonia.Controls.Primitives;
-using Avalonia.Interactivity;
 using Avalonia.Layout;
 using Avalonia.Media;
 using Avalonia.Media.Immutable;
@@ -15,7 +13,7 @@
 
 namespace Avalonia.Controls.Presenters
 {
-    public class TextPresenter : Control
+    public class TextPresenter : Control, ITextScaleable
     {
         public static readonly StyledProperty<bool> ShowSelectionHighlightProperty =
             AvaloniaProperty.Register<TextPresenter, bool>(nameof(ShowSelectionHighlight), defaultValue: true);
@@ -58,7 +56,7 @@ public class TextPresenter : Control
         /// </summary>
         public static readonly StyledProperty<string?> PreeditTextProperty =
             AvaloniaProperty.Register<TextPresenter, string?>(nameof(PreeditText));
-        
+
         /// <summary>
         /// Defines the <see cref="PreeditText"/> property.
         /// </summary>
@@ -148,7 +146,7 @@ public string? PreeditText
             get => GetValue(PreeditTextProperty);
             set => SetValue(PreeditTextProperty, value);
         }
-        
+
         public int? PreeditTextCursorPosition
         {
             get => GetValue(PreeditTextCursorPositionProperty);
@@ -335,6 +333,8 @@ public int SelectionEnd
 
         internal TextSelectionHandleCanvas? TextSelectionHandleCanvas { get; set; }
 
+        void ITextScaleable.OnTextScalingChanged() => InvalidateMeasure();
+
         /// <summary>
         /// Creates the <see cref="TextLayout"/> used to render the text.
         /// </summary>
@@ -349,10 +349,13 @@ private TextLayout CreateTextLayoutInternal(Size constraint, string? text, Typef
             var maxWidth = MathUtilities.IsZero(constraint.Width) ? double.PositiveInfinity : constraint.Width;
             var maxHeight = MathUtilities.IsZero(constraint.Height) ? double.PositiveInfinity : constraint.Height;
 
+            var effectiveFontSize = TextScaling.GetScaledFontSize(this, FontSize);
+            var fontScaleFactor = effectiveFontSize / FontSize;
+
             var textLayout = new TextLayout(
                 text,
                 typeface,
-                FontSize,
+                effectiveFontSize,
                 Foreground,
                 TextAlignment,
                 TextWrapping,
@@ -361,8 +364,8 @@ private TextLayout CreateTextLayoutInternal(Size constraint, string? text, Typef
                 FlowDirection,
                 maxWidth,
                 maxHeight,
-                LineHeight,
-                LetterSpacing,
+                LineHeight * fontScaleFactor,
+                LetterSpacing * fontScaleFactor,
                 0,
                 FontFeatures,
                 textStyleOverrides);
@@ -554,6 +557,7 @@ protected virtual TextLayout CreateTextLayout()
             var preeditText = PreeditText;
             var text = GetCombinedText(Text, caretIndex, preeditText);
             var typeface = new Typeface(FontFamily, FontStyle, FontWeight, FontStretch);
+            var effectiveFontSize = TextScaling.GetScaledFontSize(this, FontSize);
             var selectionStart = SelectionStart;
             var selectionEnd = SelectionEnd;
             var start = Math.Min(selectionStart, selectionEnd);
@@ -568,7 +572,7 @@ protected virtual TextLayout CreateTextLayout()
                 var preeditHighlight = new ValueSpan<TextRunProperties>(caretIndex, preeditText.Length,
                         new GenericTextRunProperties(
                             typeface,
-                            FontSize,
+                            effectiveFontSize,
                             TextDecorations.Underline,
                             foreground,
                             fontFeatures: FontFeatures));
@@ -587,7 +591,7 @@ protected virtual TextLayout CreateTextLayout()
                         new ValueSpan<TextRunProperties>(start, length,
                         new GenericTextRunProperties(
                             typeface,
-                            FontSize,
+                            effectiveFontSize,
                             foregroundBrush: SelectionForegroundBrush,
                             fontFeatures: FontFeatures))
                     };
@@ -766,7 +770,7 @@ public void MoveCaretVertical(LogicalDirection direction = LogicalDirection.Forw
 
             CaretChanged();
         }
-        
+
         private void EnsureCaretTimer()
         {
             if (_caretTimer == null)
@@ -792,7 +796,7 @@ private void ResetCaretTimer()
                 _caretTimer = null;
             }
 
-            if (CaretBlinkInterval.TotalMilliseconds > 0) 
+            if (CaretBlinkInterval.TotalMilliseconds > 0)
             {
                 _caretTimer = new DispatcherTimer { Interval = CaretBlinkInterval };
                 _caretTimer.Tick += CaretTimerTick;
@@ -989,7 +993,7 @@ protected override void OnDetachedFromVisualTree(VisualTreeAttachmentEventArgs e
                 _caretTimer.Tick -= CaretTimerTick;
             }
         }
-        
+
         private void OnPreeditChanged(string? preeditText, int? cursorPosition)
         {
             if (string.IsNullOrEmpty(preeditText))
@@ -1020,7 +1024,7 @@ protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs chang
             {
                 OnPreeditChanged(change.NewValue as string, PreeditTextCursorPosition);
             }
-            
+
             if(change.Property == PreeditTextCursorPositionProperty)
             {
                 OnPreeditChanged(PreeditText, PreeditTextCursorPosition);
@@ -1047,6 +1051,11 @@ protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs chang
                 ResetCaretTimer();
             }
 
+            if (change.Property.OwnerType == typeof(TextScaling))
+            {
+                InvalidateTextLayout();
+            }
+
             switch (change.Property.Name)
             {
                 case nameof(PreeditText):
diff --git a/src/Avalonia.Controls/Primitives/TextSelectionCanvas.cs b/src/Avalonia.Controls/Primitives/TextSelectionCanvas.cs
index 049188008ae..eaac5db7d83 100644
--- a/src/Avalonia.Controls/Primitives/TextSelectionCanvas.cs
+++ b/src/Avalonia.Controls/Primitives/TextSelectionCanvas.cs
@@ -154,7 +154,7 @@ private void DragSelectionHandle(TextSelectionHandle handle)
                 }
 
                 var point = ToPresenter(handle.IndicatorPosition);
-                point = point.WithY(point.Y - _presenter.FontSize / 2);
+                point = point.WithY(point.Y - TextScaling.GetScaledFontSize(_presenter, _presenter.FontSize) / 2);
                 var hit = _presenter.TextLayout.HitTestPoint(point);
                 var position = hit.CharacterHit.FirstCharacterIndex + hit.CharacterHit.TrailingLength;
 
@@ -327,9 +327,6 @@ internal bool ShowContextMenu()
             {
                 if (_textBox.ContextFlyout is PopupFlyoutBase flyout)
                 {
-                    var verticalOffset = (double.IsNaN(_textBox.LineHeight) ? _textBox.FontSize : _textBox.LineHeight) +
-                                         ContextMenuPadding;
-
                     TextSelectionHandle? handle = null;
 
                     if (_textBox.SelectionStart != _textBox.SelectionEnd)
@@ -349,6 +346,7 @@ internal bool ShowContextMenu()
 
                     if (handle != null)
                     {
+                        var verticalOffset = (_textBox.GetLineHeight() ?? 0) + ContextMenuPadding;
                         var topLeft = ToTextBox(handle.GetTopLeft());
                         flyout.VerticalOffset = topLeft.Y - verticalOffset;
                         flyout.HorizontalOffset = topLeft.X;
diff --git a/src/Avalonia.Controls/SelectableTextBlock.cs b/src/Avalonia.Controls/SelectableTextBlock.cs
index f3532763f67..2f4e035a1df 100644
--- a/src/Avalonia.Controls/SelectableTextBlock.cs
+++ b/src/Avalonia.Controls/SelectableTextBlock.cs
@@ -183,18 +183,20 @@ protected override void OnLostFocus(RoutedEventArgs e)
         protected override TextLayout CreateTextLayout(string? text)
         {
             var typeface = new Typeface(FontFamily, FontStyle, FontWeight, FontStretch);
+            var effectiveFontSize = TextScaling.GetScaledFontSize(this, FontSize);
+            var fontScaleFactor = effectiveFontSize / FontSize;
 
             var defaultProperties = new GenericTextRunProperties(
                 typeface,
-                FontSize,
+                effectiveFontSize,
                 TextDecorations,
                 Foreground,
                 fontFeatures: FontFeatures);
 
             var paragraphProperties = new GenericTextParagraphProperties(FlowDirection, TextAlignment, true, false,
-                defaultProperties, TextWrapping, LineHeight, 0, LetterSpacing)
+                defaultProperties, TextWrapping, LineHeight * fontScaleFactor, 0, LetterSpacing * fontScaleFactor)
             {
-                LineSpacing = LineSpacing
+                LineSpacing = LineSpacing * fontScaleFactor,
             };
 
             List<ValueSpan<TextRunProperties>>? textStyleOverrides = null;
@@ -235,7 +237,7 @@ protected override TextLayout CreateTextLayout(string? text)
                                 overlapLength,
                                 new GenericTextRunProperties(
                                     textRun.Properties?.Typeface ?? typeface,
-                                    FontSize,
+                                    effectiveFontSize,
                                     foregroundBrush: SelectionForegroundBrush,
                                     fontFeatures: textRun.Properties?.FontFeatures ?? FontFeatures)));
 
@@ -249,7 +251,7 @@ protected override TextLayout CreateTextLayout(string? text)
                         new ValueSpan<TextRunProperties>(start, length,
                             new GenericTextRunProperties(
                                 typeface,
-                                FontSize,
+                                effectiveFontSize,
                                 foregroundBrush: SelectionForegroundBrush,
                                 fontFeatures: FontFeatures))
                     ];
diff --git a/src/Avalonia.Controls/TextBlock.cs b/src/Avalonia.Controls/TextBlock.cs
index c70d06ae7f2..54f69f1ff0e 100644
--- a/src/Avalonia.Controls/TextBlock.cs
+++ b/src/Avalonia.Controls/TextBlock.cs
@@ -15,7 +15,7 @@ namespace Avalonia.Controls
     /// <summary>
     /// A control that displays a block of text.
     /// </summary>
-    public class TextBlock : Control, IInlineHost
+    public class TextBlock : Control, IInlineHost, ITextScaleable
     {
         /// <summary>
         /// Defines the <see cref="Background"/> property.
@@ -647,6 +647,8 @@ internal void ClearTextInternal()
             }
         }
 
+        void ITextScaleable.OnTextScalingChanged() => InvalidateMeasure();
+
         /// <summary>
         /// Creates the <see cref="TextLayout"/> used to render the text.
         /// </summary>
@@ -657,15 +659,17 @@ protected virtual TextLayout CreateTextLayout(string? text)
 
             var defaultProperties = new GenericTextRunProperties(
                 typeface,
-                FontSize,
+                TextScaling.GetScaledFontSize(this, FontSize),
                 TextDecorations,
                 Foreground,
                 fontFeatures: FontFeatures);
 
+            var fontScaleFactor = defaultProperties.FontRenderingEmSize / FontSize;
+
             var paragraphProperties = new GenericTextParagraphProperties(FlowDirection, IsMeasureValid ? TextAlignment : TextAlignment.Left, true, false,
-                defaultProperties, TextWrapping, LineHeight, 0, LetterSpacing)
+                defaultProperties, TextWrapping, LineHeight * fontScaleFactor, 0, LetterSpacing * fontScaleFactor)
             {
-                LineSpacing = LineSpacing
+                LineSpacing = LineSpacing * fontScaleFactor,
             };
 
             ITextSource textSource;
@@ -730,7 +734,7 @@ protected override Size MeasureOverride(Size availableSize)
                 //Force arrange so text will be properly aligned.
                 InvalidateArrange();
             }
-           
+
             var inlines = Inlines;
 
             if (HasComplexContent)
@@ -830,6 +834,12 @@ protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs chang
                 }
             }
 
+            if (change.Property.OwnerType == typeof(TextScaling))
+            {
+                InvalidateTextLayout();
+                return;
+            }
+
             switch (change.Property.Name)
             {
                 case nameof(FontSize):
@@ -846,6 +856,7 @@ protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs chang
 
                 case nameof(Padding):
                 case nameof(LineHeight):
+                case nameof(LineSpacing):
                 case nameof(LetterSpacing):
                 case nameof(MaxLines):
 
diff --git a/src/Avalonia.Controls/TextBox.cs b/src/Avalonia.Controls/TextBox.cs
index 447a6a41fcf..5726644a6c6 100644
--- a/src/Avalonia.Controls/TextBox.cs
+++ b/src/Avalonia.Controls/TextBox.cs
@@ -901,6 +901,20 @@ public int GetLineCount()
             return this._presenter?.TextLayout.TextLines.Count ?? -1;
         }
 
+        /// <summary>
+        /// Gets the height of each line in the <see cref="TextBox"/>, or null if no layout information is available.
+        /// </summary>
+        /// <returns></returns>
+        public double? GetLineHeight()
+        {
+            if (_presenter == null)
+                return null;
+
+            var scaledFontSize = TextScaling.GetScaledFontSize(_presenter, _presenter.FontSize);
+
+            return double.IsNaN(LineHeight) ? scaledFontSize : LineHeight * (scaledFontSize / _presenter.FontSize);
+        }
+
         /// <summary>
         /// Raised when content is being copied to the clipboard
         /// </summary>
@@ -1062,6 +1076,10 @@ protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs chang
             {
                 InvalidateMeasure();
             }
+            else if (change.Property == LineHeightProperty)
+            {
+                InvalidateMeasure();
+            }
             else if (change.Property == UndoLimitProperty)
             {
                 OnUndoLimitChanged(change.GetNewValue<int>());
@@ -2459,39 +2477,31 @@ protected override Size MeasureOverride(Size availableSize)
         {
             if (_scrollViewer != null)
             {
-                var maxHeight = double.PositiveInfinity;
-
-                if (MaxLines > 0 && double.IsNaN(Height))
-                {
-                    var fontSize = FontSize;
-                    var typeface = new Typeface(FontFamily, FontStyle, FontWeight, FontStretch);
-                    var paragraphProperties = TextLayout.CreateTextParagraphProperties(typeface, fontSize, null, default, default, null, default, LineHeight, default, FontFeatures);
-                    var textLayout = new TextLayout(new LineTextSource(MaxLines), paragraphProperties);
-                    var verticalSpace = GetVerticalSpaceBetweenScrollViewerAndPresenter();
-
-                    maxHeight = Math.Ceiling(textLayout.Height + verticalSpace);
-                }
-
-                _scrollViewer.SetCurrentValue(MaxHeightProperty, maxHeight);
-
-
-                var minHeight = 0.0;
+                _scrollViewer.SetCurrentValue(MaxHeightProperty, MaxLines > 0 && double.IsNaN(Height) ? CalculateLineDIPHeight(MaxLines) : double.PositiveInfinity);
+                _scrollViewer.SetCurrentValue(MinHeightProperty, MinLines > 0 && double.IsNaN(Height) ? CalculateLineDIPHeight(MinLines) : 0);
+            }
 
-                if (MinLines > 0 && double.IsNaN(Height))
-                {
-                    var fontSize = FontSize;
-                    var typeface = new Typeface(FontFamily, FontStyle, FontWeight, FontStretch);
-                    var paragraphProperties = TextLayout.CreateTextParagraphProperties(typeface, fontSize, null, default, default, null, default, LineHeight, default, FontFeatures);
-                    var textLayout = new TextLayout(new LineTextSource(MinLines), paragraphProperties);
-                    var verticalSpace = GetVerticalSpaceBetweenScrollViewerAndPresenter();
+            return base.MeasureOverride(availableSize);
+        }
 
-                    minHeight = Math.Ceiling(textLayout.Height + verticalSpace);
-                }
+        /// <returns>Height of <paramref name="numLines"/> lines of text in device-independent pixels.</returns>
+        private double CalculateLineDIPHeight(int numLines)
+        {
+            var effectiveFontSize = FontSize;
+            var effectiveLineHeight = LineHeight;
 
-                _scrollViewer.SetCurrentValue(MinHeightProperty, minHeight);
+            if (_presenter != null)
+            { 
+                effectiveFontSize = TextScaling.GetScaledFontSize(_presenter, effectiveFontSize);
+                effectiveLineHeight = effectiveFontSize / _presenter.FontSize * LineHeight;
             }
 
-            return base.MeasureOverride(availableSize);
+            var typeface = new Typeface(FontFamily, FontStyle, FontWeight, FontStretch);
+            var paragraphProperties = TextLayout.CreateTextParagraphProperties(typeface, effectiveFontSize, null, default, default, null, default, effectiveLineHeight, default, FontFeatures);
+            var textLayout = new TextLayout(new LineTextSource(numLines), paragraphProperties);
+            var verticalSpace = GetVerticalSpaceBetweenScrollViewerAndPresenter();
+
+            return Math.Ceiling(textLayout.Height + verticalSpace);
         }
 
         private class LineTextSource : ITextSource
diff --git a/src/Avalonia.Controls/TextScaling.cs b/src/Avalonia.Controls/TextScaling.cs
new file mode 100644
index 00000000000..6aa68d7f3ae
--- /dev/null
+++ b/src/Avalonia.Controls/TextScaling.cs
@@ -0,0 +1,139 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using Avalonia.Controls.Documents;
+using Avalonia.Threading;
+
+namespace Avalonia.Controls;
+
+/// <summary>
+/// Configures and computes text scaling. This is an accessibility feature which allows the user to request that text be 
+/// drawn at a different size than normal, without altering other UI elements. The default scaling algorithm is determined 
+/// by the platform and may make text smaller as well as larger.
+/// </summary>
+/// <remarks>
+/// Text scaling is applied when text is measured. It does not modify the value of <see cref="TextElement.FontSize"/>.
+/// </remarks>
+/// <seealso cref="ITextScaleable"/>
+/// <seealso cref="ITextScaler"/>
+public static class TextScaling
+{
+    private static readonly ConditionalWeakTable<ITextScaler, HashSet<Visual>> s_customTextScalerSubscribers = [];
+
+    /// <summary>
+    /// Determines whether <see cref="TextElement.FontSize"/> (along with <see cref="TextElement.LetterSpacing"/>, <see cref="TextBlock.LineHeight"/>, and 
+    /// <see cref="TextBlock.LineSpacing"/>) should be scalled by calling <see cref="GetScaledFontSize"/> when measuring text content. The value is inherited.
+    /// </summary>
+    /// <remarks>Text scaling is typically not uniform. Smaller text scales up faster than larger text.</remarks>
+    public static readonly AttachedProperty<bool> IsEnabledProperty =
+        AvaloniaProperty.RegisterAttached<Visual, bool>("IsEnabled", typeof(TextScaling), inherits: true);
+
+    /// <summary>
+    /// Determines the minimum size (in em units) to which text will be scaled by <see cref="GetScaledFontSize"/>. The value is inherited.
+    /// </summary>
+    /// <remarks>This value is used only when <see cref="IsEnabledProperty"/> is true.</remarks>
+    public static readonly AttachedProperty<double> MinFontSizeProperty =
+        AvaloniaProperty.RegisterAttached<Visual, double>("MinFontSize", typeof(TextScaling), inherits: true, validate: size => size >= 0);
+
+    /// <summary>
+    /// Determines the maximum size (in em units) to which text will be scaled by <see cref="GetScaledFontSize"/>. The value is inherited.
+    /// </summary>
+    /// <remarks>This value is used only when <see cref="IsEnabledProperty"/> is true.</remarks>
+    public static readonly AttachedProperty<double> MaxFontSizeProperty =
+        AvaloniaProperty.RegisterAttached<Visual, double>("MaxFontSize", typeof(TextScaling), defaultValue: double.PositiveInfinity, inherits: true,
+            validate: size => size > 0);
+
+    /// <summary>
+    /// Determines a user-defined text scaling algorithm, which overrides platform text scaling in <see cref="GetScaledFontSize"/>. The value is inherited.
+    /// </summary>
+    /// <remarks>This value is used only when <see cref="IsEnabledProperty"/> is true.</remarks>
+    public static readonly AttachedProperty<ITextScaler?> CustomTextScalerProperty =
+        AvaloniaProperty.RegisterAttached<Visual, ITextScaler?>("CustomTextScaler", typeof(TextScaling), inherits: true);
+  
+    /// <inheritdoc cref="IsEnabledProperty"/> <see cref="IsEnabledProperty"/>
+    public static bool GetIsEnabled(Visual visual) => visual.GetValue(IsEnabledProperty);
+    /// <inheritdoc cref="IsEnabledProperty"/> <see cref="IsEnabledProperty"/>
+    public static void SetIsEnabled(Visual visual, bool value) => visual.SetValue(IsEnabledProperty, value);
+    /// <inheritdoc cref="MinFontSizeProperty"/> <see cref="MinFontSizeProperty"/>
+    public static double GetMinFontSize(Visual visual) => visual.GetValue(MinFontSizeProperty);
+    /// <inheritdoc cref="MinFontSizeProperty"/> <see cref="MinFontSizeProperty"/>
+    public static void SetMinFontSize(Visual visual, double value) => visual.SetValue(MinFontSizeProperty, value);
+    /// <inheritdoc cref="MaxFontSizeProperty"/> <see cref="MaxFontSizeProperty"/>
+    public static double GetMaxFontSize(Visual visual) => visual.GetValue(MaxFontSizeProperty);
+    /// <inheritdoc cref="MaxFontSizeProperty"/> <see cref="MaxFontSizeProperty"/>
+    public static void SetMaxFontSize(Visual visual, double value) => visual.SetValue(MaxFontSizeProperty, value);
+    /// <inheritdoc cref="CustomTextScalerProperty"/> <see cref="CustomTextScalerProperty"/>
+    public static ITextScaler? GetCustomTextScaler(Visual visual) => visual.GetValue(CustomTextScalerProperty);
+    /// <inheritdoc cref="CustomTextScalerProperty"/> <see cref="CustomTextScalerProperty"/>
+    public static void SetCustomTextScaler(Visual visual, ITextScaler? value) => visual.SetValue(CustomTextScalerProperty, value);
+
+    static TextScaling()
+    {
+        CustomTextScalerProperty.Changed.AddClassHandler<Visual>(OnCustomTextScalerChanged);
+    }
+
+    private static void OnCustomTextScalerChanged(Visual visual, AvaloniaPropertyChangedEventArgs args)
+    {
+        if (visual is not ITextScaleable)
+        {
+            return;
+        }
+
+        var (oldScaler, newScaler) = args.GetOldAndNewValue<ITextScaler?>();
+
+        if (oldScaler != null && s_customTextScalerSubscribers.TryGetValue(oldScaler, out var oldSubscribers))
+        {
+            oldSubscribers.Remove(visual);
+        }
+
+        if (newScaler != null)
+        {
+            if (s_customTextScalerSubscribers.TryGetValue(newScaler, out var newSubscribers))
+            {
+                newSubscribers.Add(visual);
+            }
+            else
+            {
+                s_customTextScalerSubscribers.Add(newScaler, [visual]);
+                newScaler.TextScalingChanged += OnCustomTextScalingChanged;
+            }
+        }
+    }
+
+    private static void OnCustomTextScalingChanged(object? sender, EventArgs e)
+    {
+        Dispatcher.UIThread.VerifyAccess();
+
+        if (sender is ITextScaler scaler && s_customTextScalerSubscribers.TryGetValue(scaler, out var subscribers))
+        {
+            foreach (var visual in subscribers)
+            {
+                if (GetIsEnabled(visual))
+                {
+                    ((ITextScaleable)visual).OnTextScalingChanged();
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// Scales <paramref name="baseFontSize"/> according to either the current platform text scaling rules, or the rules
+    /// defined by the object assigned to <see cref="CustomTextScalerProperty"/> for <paramref name="visual"/>.
+    /// </summary>
+    /// <remarks>The values of <see cref="IsEnabledProperty"/>, <see cref="MinFontSizeProperty"/>, and <see cref="MaxFontSizeProperty"/>
+    /// are enforced, even when <see cref="CustomTextScalerProperty"/> is in use.</remarks>
+    public static double GetScaledFontSize(Visual visual, double baseFontSize)
+    {
+        if (double.IsNaN(baseFontSize) || baseFontSize <= 0 || !GetIsEnabled(visual) || 
+            (GetCustomTextScaler(visual) ?? TopLevel.GetTopLevel(visual)?.PlatformSettings) is not { } scaler)
+        {
+            return baseFontSize;
+        }
+
+        // Extend min/max to encompass the base size. Conveniently, this means that min > max is not possible.
+        var min = Math.Min(GetMinFontSize(visual), baseFontSize);
+        var max = Math.Max(GetMaxFontSize(visual), baseFontSize);
+
+        return Math.Clamp(scaler.GetScaledFontSize(visual, baseFontSize), min, max);
+    }
+}
diff --git a/src/Avalonia.Controls/TopLevel.cs b/src/Avalonia.Controls/TopLevel.cs
index 8a631fe075b..d598cfc5ab3 100644
--- a/src/Avalonia.Controls/TopLevel.cs
+++ b/src/Avalonia.Controls/TopLevel.cs
@@ -26,6 +26,7 @@
 using Avalonia.Diagnostics;
 using Avalonia.Rendering.Composition;
 using Avalonia.Threading;
+using Avalonia.VisualTree;
 
 namespace Avalonia.Controls
 {
@@ -245,6 +246,8 @@ public TopLevel(ITopLevelImpl impl, IAvaloniaDependencyResolver? dependencyResol
                 PlatformImpl?.SetFrameThemeVariant((PlatformThemeVariant?)variant ?? PlatformThemeVariant.Light);
             });
 
+            PlatformSettings?.TextScalingChanged += OnPlatformTextScalingChanged;
+
             _keyboardNavigationHandler?.SetOwner(this);
             _accessKeyHandler?.SetOwner(this);
 
@@ -324,6 +327,20 @@ public TopLevel(ITopLevelImpl impl, IAvaloniaDependencyResolver? dependencyResol
                 }
             });
         }
+
+        private void OnPlatformTextScalingChanged(object? sender, EventArgs e)
+        {
+            foreach (var visual in this.GetVisualDescendants())
+            {
+                if (visual is not ITextScaleable scaleable || !TextScaling.GetIsEnabled(visual) || TextScaling.GetCustomTextScaler(visual) != null)
+                {
+                    continue;
+                }
+
+                scaleable.OnTextScalingChanged();
+            }
+        }
+
         /// <summary>
         /// Fired when the window is opened.
         /// </summary>
diff --git a/src/Windows/Avalonia.Win32/Win32PlatformSettings.cs b/src/Windows/Avalonia.Win32/Win32PlatformSettings.cs
index c4b016c1b92..35a8c41a4f1 100644
--- a/src/Windows/Avalonia.Win32/Win32PlatformSettings.cs
+++ b/src/Windows/Avalonia.Win32/Win32PlatformSettings.cs
@@ -8,11 +8,22 @@ namespace Avalonia.Win32;
 
 internal class Win32PlatformSettings : DefaultPlatformSettings
 {
-    private static readonly Lazy<bool> s_uiSettingsSupported = new(() =>
-        WinRTApiInformation.IsTypePresent("Windows.UI.ViewManagement.UISettings")
-        && WinRTApiInformation.IsTypePresent("Windows.UI.ViewManagement.AccessibilitySettings")); 
-
     private PlatformColorValues? _lastColorValues;
+    private double _textScaleFactor = s_uiSettings2?.TextScaleFactor ?? 1;
+
+    private static readonly IUISettings2? s_uiSettings2;
+    private static readonly bool s_uiSettingsSupported;
+
+    static Win32PlatformSettings()
+    {
+        s_uiSettingsSupported = WinRTApiInformation.IsTypePresent("Windows.UI.ViewManagement.UISettings")
+        && WinRTApiInformation.IsTypePresent("Windows.UI.ViewManagement.AccessibilitySettings");
+
+        if (s_uiSettingsSupported)
+        {
+            s_uiSettings2 = NativeWinRTMethods.CreateInstance<IUISettings2>("Windows.UI.ViewManagement.UISettings");
+        }
+    }
 
     public override Size GetTapSize(PointerType type)
     {
@@ -33,10 +44,10 @@ public override Size GetDoubleTapSize(PointerType type)
     }
 
     public override TimeSpan GetDoubleTapTime(PointerType type) => TimeSpan.FromMilliseconds(GetDoubleClickTime());
-    
+
     public override PlatformColorValues GetColorValues()
     {
-        if (!s_uiSettingsSupported.Value)
+        if (!s_uiSettingsSupported)
         {
             return base.GetColorValues();
         }
@@ -74,10 +85,10 @@ public override PlatformColorValues GetColorValues()
                     PlatformThemeVariant.Light,
                 ContrastPreference = ColorContrastPreference.NoPreference,
                 AccentColor1 = accent
-            };   
+            };
         }
     }
-    
+
     internal void OnColorValuesChanged()
     {
         var oldColorValues = _lastColorValues;
@@ -87,5 +98,25 @@ internal void OnColorValuesChanged()
         {
             OnColorValuesChanged(colorValues);
         }
+
+        var newTextScaleFactor = s_uiSettings2?.TextScaleFactor ?? 1;
+        if (newTextScaleFactor != _textScaleFactor)
+        {
+            _textScaleFactor = newTextScaleFactor;
+            OnTextScaleChanged();
+        }
+    }
+
+    /// <summary>
+    /// The algorithm used is undocumented, but <see href="https://github.com/microsoft/microsoft-ui-xaml/blob/5788dee271452753d5b2c70179f976c3e96a45c7/src/dxaml/xcp/core/text/common/TextFormatting.cpp#L181-L204">defined in Microsoft's source code</see>.
+    /// </summary>
+    public override double GetScaledFontSize(Visual target, double baseFontSize)
+    {
+        if (baseFontSize <= 0 || _textScaleFactor == 1)
+        {
+            return baseFontSize;
+        }
+
+        return Math.Max(1, baseFontSize) + Math.Max(-Math.Exp(1) * Math.Log(baseFontSize) + 18, 0.0) * (_textScaleFactor - 1);
     }
 }
diff --git a/src/Windows/Avalonia.Win32/WinRT/winrt.idl b/src/Windows/Avalonia.Win32/WinRT/winrt.idl
index b80a0de11bd..b416ccafc9c 100644
--- a/src/Windows/Avalonia.Win32/WinRT/winrt.idl
+++ b/src/Windows/Avalonia.Win32/WinRT/winrt.idl
@@ -859,6 +859,15 @@ enum UIColorType
     Complement = 9
 }
 
+[uuid(BAD82401-2721-44F9-BB91-2BB228BE442F)]
+interface IUISettings2 : IInspectable
+{
+    [propget] HRESULT GetTextScaleFactor([out][retval] DOUBLE* value);
+    
+    [eventadd] HRESULT AddTextScaleFactorChanged([in] void* handler, [out][retval] int* token);
+    [eventremove] HRESULT RemoveTextScaleFactorChanged([in] int token);
+}
+
 [uuid(03021BE4-5254-4781-8194-5168F7D06D7B)]
 interface IUISettings3 : IInspectable
 {
diff --git a/src/iOS/Avalonia.iOS/PlatformSettings.cs b/src/iOS/Avalonia.iOS/PlatformSettings.cs
index 43cd7317012..71ba1c81446 100644
--- a/src/iOS/Avalonia.iOS/PlatformSettings.cs
+++ b/src/iOS/Avalonia.iOS/PlatformSettings.cs
@@ -1,6 +1,8 @@
 using System;
+using System.Collections.Generic;
 using Avalonia.Media;
 using Avalonia.Platform;
+using Foundation;
 using UIKit;
 
 namespace Avalonia.iOS;
@@ -8,8 +10,27 @@ namespace Avalonia.iOS;
 // TODO: ideally should be created per view/activity.
 internal class PlatformSettings : DefaultPlatformSettings
 {
+    private readonly NSObject _contentSizeChangedToken;
+    private readonly Dictionary<double, double> _fontScaleCache = [];
+
     private PlatformColorValues? _lastColorValues;
 
+    public PlatformSettings()
+    {
+        _contentSizeChangedToken = UIApplication.Notifications.ObserveContentSizeCategoryChanged(OnContentSizeCategoryChanged);
+    }
+
+    ~PlatformSettings()
+    {
+        _contentSizeChangedToken.Dispose();
+    }
+
+    private void OnContentSizeCategoryChanged(object? sender, UIContentSizeCategoryChangedEventArgs e)
+    {
+        _fontScaleCache.Clear();
+        OnTextScaleChanged();
+    }
+
     public override PlatformColorValues GetColorValues()
     {
         var themeVariant = UITraitCollection.CurrentTraitCollection.UserInterfaceStyle == UIUserInterfaceStyle.Dark ?
@@ -61,4 +82,20 @@ public void TraitCollectionDidChange()
             OnColorValuesChanged(colorValues);
         }
     }
+
+    public override double GetScaledFontSize(Visual target, double baseFontSize)
+    {
+        if (baseFontSize <= 0)
+        {
+            return baseFontSize;
+        }
+
+        if (!_fontScaleCache.TryGetValue(baseFontSize, out var scaledSize))
+        {
+            var font = UIFont.SystemFontOfSize((nfloat)baseFontSize);
+            scaledSize = _fontScaleCache[baseFontSize] = UIFontMetrics.DefaultMetrics.GetScaledFont(font).PointSize;
+        }
+
+        return scaledSize;
+    }
 }