From df1816bde5e226b34ff9a660bd49c0786c51c257 Mon Sep 17 00:00:00 2001
From: Alexander Marek <gentledepp@gmail.com>
Date: Mon, 4 Aug 2025 16:12:02 +0200
Subject: [PATCH] #18626 - improved scrolling performance in
 VirtualizingStackPanel.cs by reducing Measure/Arrange calls since they cause
 heavy GC pressure on constrained devices (Android, iOS) especially with
 complex item views (#18646)

Co-authored-by: alexander.marek <alexander.marek@opti-q.com>
Co-authored-by: Steven Kirk <grokys@users.noreply.github.com>
Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
---
 samples/ControlCatalog/Pages/ListBoxPage.xaml |    3 +
 .../VirtualizingStackPanel.cs                 |  209 ++-
 .../VirtualizingStackPanelTests.cs            | 1407 +++++++++++++----
 3 files changed, 1340 insertions(+), 279 deletions(-)

diff --git a/samples/ControlCatalog/Pages/ListBoxPage.xaml b/samples/ControlCatalog/Pages/ListBoxPage.xaml
index 7694845009..e3a706bfed 100644
--- a/samples/ControlCatalog/Pages/ListBoxPage.xaml
+++ b/samples/ControlCatalog/Pages/ListBoxPage.xaml
@@ -20,6 +20,9 @@
         <Setter Property="Background" Value="Blue" />
         <Setter Property="FontWeight" Value="Bold" />
       </Style>
+	  <Style Selector="VirtualizingStackPanel">
+	    <Setter Property="CacheLength" Value="0.5" />
+	  </Style>
     </DockPanel.Styles>
     <StackPanel DockPanel.Dock="Top" Margin="4">
       <TextBlock Classes="h2">Hosts a collection of ListBoxItem.</TextBlock>
diff --git a/src/Avalonia.Controls/VirtualizingStackPanel.cs b/src/Avalonia.Controls/VirtualizingStackPanel.cs
index adeebf97d9..e883bb533b 100644
--- a/src/Avalonia.Controls/VirtualizingStackPanel.cs
+++ b/src/Avalonia.Controls/VirtualizingStackPanel.cs
@@ -8,6 +8,7 @@ using Avalonia.Controls.Utils;
 using Avalonia.Input;
 using Avalonia.Interactivity;
 using Avalonia.Layout;
+using Avalonia.Reactive;
 using Avalonia.Utilities;
 using Avalonia.VisualTree;
 
@@ -51,6 +52,12 @@ namespace Avalonia.Controls
             RoutedEvent.Register<VirtualizingStackPanel, RoutedEventArgs>(
                 nameof(VerticalSnapPointsChanged),
                 RoutingStrategies.Bubble);
+        /// <summary>
+        /// Defines the <see cref="CacheLength"/> property.
+        /// </summary>
+        public static readonly StyledProperty<double> CacheLengthProperty =
+            AvaloniaProperty.Register<VirtualizingStackPanel, double>(nameof(CacheLength), 0.0, 
+                validate: v => v is >= 0 and <= 2);
 
         private static readonly AttachedProperty<object?> RecycleKeyProperty =
             AvaloniaProperty.RegisterAttached<VirtualizingStackPanel, Control, object?>("RecycleKey");
@@ -73,12 +80,24 @@ namespace Avalonia.Controls
         private int _focusedIndex = -1;
         private Control? _realizingElement;
         private int _realizingIndex = -1;
+        private double _bufferFactor; 
+        
+        private bool _hasReachedStart = false;
+        private bool _hasReachedEnd = false;
+        private Rect _extendedViewport;
+
+        static VirtualizingStackPanel()
+        {
+            CacheLengthProperty.Changed.AddClassHandler<VirtualizingStackPanel>((x, e) => x.OnCacheLengthChanged(e));
+        }
 
         public VirtualizingStackPanel()
         {
             _recycleElement = RecycleElement;
             _recycleElementOnItemRemoved = RecycleElementOnItemRemoved;
             _updateElementIndex = UpdateElementIndex;
+
+            _bufferFactor = Math.Max(0, CacheLength);
             EffectiveViewportChanged += OnEffectiveViewportChanged;
         }
 
@@ -131,6 +150,20 @@ namespace Avalonia.Controls
             set => SetValue(AreVerticalSnapPointsRegularProperty, value);
         }
 
+        /// <summary>
+        /// Gets or sets the CacheLength.
+        /// </summary>
+        /// <remarks>The factor determines how much additional space to maintain above and below the viewport.
+        /// A value of 0.5 means half the viewport size will be buffered on each side (up-down or left-right)
+        /// This uses more memory as more UI elements are realized, but greatly reduces the number of Measure-Arrange
+        /// cycles which can cause heavy GC pressure depending on the complexity of the item layouts.
+        /// </remarks>
+        public double CacheLength
+        {
+            get => GetValue(CacheLengthProperty);
+            set => SetValue(CacheLengthProperty, value);
+        }
+
         /// <summary>
         /// Gets the index of the first realized element, or -1 if no elements are realized.
         /// </summary>
@@ -141,6 +174,16 @@ namespace Avalonia.Controls
         /// </summary>
         public int LastRealizedIndex => _realizedElements?.LastIndex ?? -1;
 
+        /// <summary>
+        /// Returns the viewport that contains any visible elements
+        /// </summary>
+        internal Rect ViewPort => _viewport;
+
+        /// <summary>
+        /// Returns the extended viewport that contains any visible elements and the additional elements for fast scrolling (viewport * CacheLength * 2)
+        /// </summary>
+        internal Rect ExtendedViewPort => _extendedViewport;
+
         protected override Size MeasureOverride(Size availableSize)
         {
             var items = Items;
@@ -217,8 +260,12 @@ namespace Avalonia.Controls
                         var rect = orientation == Orientation.Horizontal ?
                             new Rect(u, 0, sizeU, finalSize.Height) :
                             new Rect(0, u, finalSize.Width, sizeU);
+
                         e.Arrange(rect);
-                        _scrollAnchorProvider?.RegisterAnchorCandidate(e);
+                    
+                        if (_viewport.Intersects(rect))
+                            _scrollAnchorProvider?.RegisterAnchorCandidate(e);
+                        
                         u += orientation == Orientation.Horizontal ? rect.Width : rect.Height;
                     }
                 }
@@ -230,6 +277,7 @@ namespace Avalonia.Controls
                     var rect = orientation == Orientation.Horizontal ?
                         new Rect(u, 0, _focusedElement.DesiredSize.Width, finalSize.Height) :
                         new Rect(0, u, finalSize.Width, _focusedElement.DesiredSize.Height);
+
                     _focusedElement.Arrange(rect);
                 }
 
@@ -416,6 +464,7 @@ namespace Avalonia.Controls
                 // Create and measure the element to be brought into view. Store it in a field so that
                 // it can be re-used in the layout pass.
                 var scrollToElement = GetOrCreateElement(items, index);
+
                 scrollToElement.Measure(Size.Infinity);
 
                 // Get the expected position of the element and put it in place.
@@ -483,7 +532,8 @@ namespace Avalonia.Controls
         {
             Debug.Assert(_realizedElements is not null);
 
-            var viewport = _viewport;
+            // Use the extended viewport for calculations
+            var viewport = _extendedViewport;
 
             // Get the viewport in the orientation direction.
             var viewportStart = orientation == Orientation.Horizontal ? viewport.X : viewport.Y;
@@ -653,7 +703,6 @@ namespace Avalonia.Controls
             return index * estimatedSize;
         }
 
-
         private void RealizeElements(
             IReadOnlyList<object?> items,
             Size availableSize,
@@ -666,6 +715,10 @@ namespace Avalonia.Controls
             var index = viewport.anchorIndex;
             var horizontal = Orientation == Orientation.Horizontal;
             var u = viewport.anchorU;
+                    
+            // Reset boundary flags
+            _hasReachedStart = false;
+            _hasReachedEnd = false;
 
             // If the anchor element is at the beginning of, or before, the start of the viewport
             // then we can recycle all elements before it.
@@ -678,8 +731,9 @@ namespace Avalonia.Controls
                 _realizingIndex = index;
                 var e = GetOrCreateElement(items, index);
                 _realizingElement = e;
+                
                 e.Measure(availableSize);
-
+                
                 var sizeU = horizontal ? e.DesiredSize.Width : e.DesiredSize.Height;
                 var sizeV = horizontal ? e.DesiredSize.Height : e.DesiredSize.Width;
 
@@ -691,7 +745,10 @@ namespace Avalonia.Controls
                 _realizingIndex = -1;
                 _realizingElement = null;
             } while (u < viewport.viewportUEnd && index < items.Count);
-
+            
+            // Check if we reached the end of the collection
+            _hasReachedEnd = index >= items.Count;
+            
             // Store the last index and end U position for the desired size calculation.
             viewport.lastIndex = index - 1;
             viewport.realizedEndU = u;
@@ -706,8 +763,8 @@ namespace Avalonia.Controls
             while (u > viewport.viewportUStart && index >= 0)
             {
                 var e = GetOrCreateElement(items, index);
+                
                 e.Measure(availableSize);
-
                 var sizeU = horizontal ? e.DesiredSize.Width : e.DesiredSize.Height;
                 var sizeV = horizontal ? e.DesiredSize.Height : e.DesiredSize.Width;
                 u -= sizeU;
@@ -716,6 +773,9 @@ namespace Avalonia.Controls
                 viewport.measuredV = Math.Max(viewport.measuredV, sizeV);
                 --index;
             }
+            
+            // Check if we reached the start of the collection
+            _hasReachedStart = index < 0;
 
             // We can now recycle elements before the first element.
             _realizedElements.RecycleElementsBefore(index + 1, _recycleElement);
@@ -748,7 +808,7 @@ namespace Avalonia.Controls
         {
             return _realizedElements?.GetElement(index);
         }
-
+        
         private static Control? GetRealizedElement(
             int index,
             ref int specialIndex,
@@ -891,22 +951,146 @@ namespace Avalonia.Controls
 
             ItemContainerGenerator.ItemContainerIndexChanged(element, oldIndex, newIndex);
         }
-
+        
         private void OnEffectiveViewportChanged(object? sender, EffectiveViewportChangedEventArgs e)
         {
             var vertical = Orientation == Orientation.Vertical;
             var oldViewportStart = vertical ? _viewport.Top : _viewport.Left;
             var oldViewportEnd = vertical ? _viewport.Bottom : _viewport.Right;
+            var oldExtendedViewportStart = vertical ? _extendedViewport.Top : _extendedViewport.Left;
+            var oldExtendedViewportEnd = vertical ? _extendedViewport.Bottom : _extendedViewport.Right;
 
+            // Update current viewport
             _viewport = e.EffectiveViewport.Intersect(new(Bounds.Size));
             _isWaitingForViewportUpdate = false;
 
+            // Calculate buffer sizes based on viewport dimensions
+            var viewportSize = vertical ? _viewport.Height : _viewport.Width;
+            var bufferSize = viewportSize * _bufferFactor;
+            
+            // Calculate extended viewport with relative buffers
+            var extendedViewportStart = vertical ? 
+                Math.Max(0, _viewport.Top - bufferSize) : 
+                Math.Max(0, _viewport.Left - bufferSize);
+                
+            var extendedViewportEnd = vertical ? 
+                Math.Min(Bounds.Height, _viewport.Bottom + bufferSize) : 
+                Math.Min(Bounds.Width, _viewport.Right + bufferSize);
+
+            // special case:
+            // If we are at the start of the list, append 2 * CacheLength additional items
+            // If we are at the end of the list, prepend 2 * CacheLength additional items
+            // - this way we always maintain "2 * CacheLength * element" items. 
+            if (vertical)
+            {
+                var spaceAbove = _viewport.Top - bufferSize;
+                var spaceBelow = Bounds.Height - (_viewport.Bottom + bufferSize);
+                
+                if (spaceAbove < 0 && spaceBelow >= 0)
+                    extendedViewportEnd = Math.Min(Bounds.Height, extendedViewportEnd + Math.Abs(spaceAbove));
+                if (spaceAbove >= 0 && spaceBelow < 0)
+                    extendedViewportStart = Math.Max(0, extendedViewportStart - Math.Abs(spaceBelow));
+            }
+            else
+            {
+                var spaceLeft = _viewport.Left - bufferSize;
+                var spaceRight = Bounds.Width - (_viewport.Right + bufferSize);
+                
+                if (spaceLeft < 0 && spaceRight >= 0)
+                    extendedViewportEnd = Math.Min(Bounds.Width, extendedViewportEnd + Math.Abs(spaceLeft));
+                if(spaceLeft >= 0 && spaceRight < 0)
+                    extendedViewportStart = Math.Max(0, extendedViewportStart - Math.Abs(spaceRight));
+            }
+
+            Rect extendedViewPort;
+            if (vertical)
+            {
+                extendedViewPort = new Rect(
+                    _viewport.X, 
+                    extendedViewportStart,
+                    _viewport.Width,
+                    extendedViewportEnd - extendedViewportStart);
+            }
+            else
+            {
+                extendedViewPort = new Rect(
+                    extendedViewportStart,
+                    _viewport.Y,
+                    extendedViewportEnd - extendedViewportStart,
+                    _viewport.Height);
+            }
+
+            // Determine if we need a new measure
             var newViewportStart = vertical ? _viewport.Top : _viewport.Left;
             var newViewportEnd = vertical ? _viewport.Bottom : _viewport.Right;
+            var newExtendedViewportStart = vertical ? extendedViewPort.Top : extendedViewPort.Left;
+            var newExtendedViewportEnd = vertical ? extendedViewPort.Bottom : extendedViewPort.Right;
 
+            var needsMeasure = false;
+            
+           
+            // Case 1: Viewport has changed significantly
             if (!MathUtilities.AreClose(oldViewportStart, newViewportStart) ||
                 !MathUtilities.AreClose(oldViewportEnd, newViewportEnd))
             {
+                // Case 1a: The new viewport exceeds the old extended viewport
+                if (newViewportStart < oldExtendedViewportStart || 
+                    newViewportEnd > oldExtendedViewportEnd)
+                {
+                    needsMeasure = true;
+                }
+                // Case 1b: The extended viewport has changed significantly
+                else if (!MathUtilities.AreClose(oldExtendedViewportStart, newExtendedViewportStart) ||
+                         !MathUtilities.AreClose(oldExtendedViewportEnd, newExtendedViewportEnd))
+                {
+                    // Check if we're about to scroll into an area where we don't have realized elements
+                    // This would be the case if we're near the edge of our current extended viewport
+                    var nearingEdge = false;
+                    
+                    if (_realizedElements != null)
+                    {
+                        var firstRealizedElementU = _realizedElements.StartU;
+                        var lastRealizedElementU = _realizedElements.StartU;
+                        
+                        for (var i = 0; i < _realizedElements.Count; i++)
+                        {
+                            lastRealizedElementU += _realizedElements.SizeU[i];
+                        }
+                        
+                        // If scrolling up/left and nearing the top/left edge of realized elements
+                        if (newViewportStart < oldViewportStart && 
+                            newViewportStart - newExtendedViewportStart < bufferSize)
+                        {
+                            // Edge case: We're at item 0 with excess measurement space.
+                            // Skip re-measuring since we're at the list start and it won't change the result.
+                            // This prevents redundant Measure-Arrange cycles when at list beginning.
+                            nearingEdge = !_hasReachedStart;
+                        }
+                        
+                        // If scrolling down/right and nearing the bottom/right edge of realized elements
+                        if (newViewportEnd > oldViewportEnd && 
+                            newExtendedViewportEnd - newViewportEnd < bufferSize)
+                        {
+                            // Edge case: We're at the last item with excess measurement space.
+                            // Skip re-measuring since we're at the list end and it won't change the result.
+                            // This prevents redundant Measure-Arrange cycles when at list beginning.
+                            nearingEdge = !_hasReachedEnd;
+                        }
+                    }
+                    else
+                    {
+                        nearingEdge = true;
+                    }
+                    
+                    needsMeasure = nearingEdge;
+                }
+            }
+
+            if (needsMeasure)
+            {
+                // only store the new "old" extended viewport if we _did_ actually measure
+                _extendedViewport = extendedViewPort;
+                
                 InvalidateMeasure();
             }
         }
@@ -924,6 +1108,15 @@ namespace Avalonia.Controls
             }
         }
 
+        private void OnCacheLengthChanged(AvaloniaPropertyChangedEventArgs e)
+        {
+            var newValue = e.GetNewValue<double>();
+            _bufferFactor = newValue;
+    
+            // Force a recalculation of the extended viewport on the next layout pass
+            InvalidateMeasure();
+        }
+        
         /// <inheritdoc/>
         public IReadOnlyList<double> GetIrregularSnapPoints(Orientation orientation, SnapPointsAlignment snapPointsAlignment)
         {
diff --git a/tests/Avalonia.Controls.UnitTests/VirtualizingStackPanelTests.cs b/tests/Avalonia.Controls.UnitTests/VirtualizingStackPanelTests.cs
index 0b33239687..6c6252d836 100644
--- a/tests/Avalonia.Controls.UnitTests/VirtualizingStackPanelTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/VirtualizingStackPanelTests.cs
@@ -3,6 +3,7 @@ using System.Collections;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Collections.Specialized;
+using System.Diagnostics;
 using System.Linq;
 using Avalonia.Collections;
 using Avalonia.Controls.Presenters;
@@ -24,137 +25,167 @@ namespace Avalonia.Controls.UnitTests
     public class VirtualizingStackPanelTests : ScopedTestBase
     {
         private static FuncDataTemplate<ItemWithHeight> CanvasWithHeightTemplate = new((_, _) =>
-            new Canvas
+            new CanvasCountingMeasureArrangeCalls
             {
                 Width = 100,
                 [!Layoutable.HeightProperty] = new Binding("Height"),
             });
 
         private static FuncDataTemplate<ItemWithWidth> CanvasWithWidthTemplate = new((_, _) =>
-            new Canvas
+            new CanvasCountingMeasureArrangeCalls
             {
                 Height = 100,
                 [!Layoutable.WidthProperty] = new Binding("Width"),
             });
 
-        [Fact]
-        public void Creates_Initial_Items()
+        [Theory]
+        [InlineData(0d  , 10)]
+        [InlineData(0.5d, 20)]
+        public void Creates_Initial_Items(double bufferFactor, int expectedCount)
         {
             using var app = App();
-            var (target, scroll, itemsControl) = CreateTarget();
+            var (target, scroll, itemsControl) = CreateTarget(bufferFactor:bufferFactor);
 
             Assert.Equal(1000, scroll.Extent.Height);
 
-            AssertRealizedItems(target, itemsControl, 0, 10);
+            AssertRealizedItems(target, itemsControl, 0, expectedCount);
         }
 
-        [Fact]
-        public void Initializes_Initial_Control_Items()
+        [Theory]
+        [InlineData(0d, 10)]
+        [InlineData(0.5d, 20)]  // Buffer factor of 0.5. Since at start there is no room, the 10 additional items are just appended
+        public void Initializes_Initial_Control_Items(double bufferFactor, int expectedCount)
         {
             using var app = App();
             var items = Enumerable.Range(0, 100).Select(x => new Button { Width = 25, Height = 10 });
-            var (target, scroll, itemsControl) = CreateTarget(items: items, itemTemplate: null);
+            var (target, scroll, itemsControl) = CreateTarget(items: items, itemTemplate: null, bufferFactor:bufferFactor);
 
             Assert.Equal(1000, scroll.Extent.Height);
 
-            AssertRealizedControlItems<Button>(target, itemsControl, 0, 10);
+            AssertRealizedControlItems<Button>(target, itemsControl, 0, expectedCount);
         }
 
-        [Fact]
-        public void Creates_Reassigned_Items()
+        [Theory]
+        [InlineData(0d, 2)]
+        [InlineData(0.5d, 2)]  
+        public void Creates_Reassigned_Items(double bufferFactor, int expectedCount)
         {
             using var app = App();
-            var (target, scroll, itemsControl) = CreateTarget(items: Array.Empty<object>());
+            var (target, scroll, itemsControl) = CreateTarget(items: Array.Empty<object>(), bufferFactor: bufferFactor);
 
             Assert.Empty(itemsControl.GetRealizedContainers());
 
             itemsControl.ItemsSource = new[] { "foo", "bar" };
             Layout(target);
 
-            AssertRealizedItems(target, itemsControl, 0, 2);
+            AssertRealizedItems(target, itemsControl, 0, expectedCount);
         }
 
-        [Fact]
-        public void Scrolls_Down_One_Item()
+        [Theory]
+        [InlineData(0d, 1, 10)]
+        [InlineData(0.5d, 0, 20)]
+        public void Scrolls_Down_One_Item(double bufferFactor, int expectedFirstIndex, int expectedCount)
         {
             using var app = App();
-            var (target, scroll, itemsControl) = CreateTarget();
+            var (target, scroll, itemsControl) = CreateTarget(bufferFactor:bufferFactor);
 
             scroll.Offset = new Vector(0, 10);
             Layout(target);
 
-            AssertRealizedItems(target, itemsControl, 1, 10);
+            AssertRealizedItems(target, itemsControl, expectedFirstIndex, expectedCount);
         }
 
-        [Fact]
-        public void Scrolls_Down_More_Than_A_Page()
+        [Theory]
+        [InlineData(0d, 20,10)]
+        [InlineData(0.5d, 15,20)]
+        public void Scrolls_Down_More_Than_A_Page(double bufferFactor, int expectedFirstIndex, int expectedCount)
         {
             using var app = App();
-            var (target, scroll, itemsControl) = CreateTarget();
+            var (target, scroll, itemsControl) = CreateTarget(bufferFactor:bufferFactor);
 
             scroll.Offset = new Vector(0, 200);
             Layout(target);
 
-            AssertRealizedItems(target, itemsControl, 20, 10);
+            AssertRealizedItems(target, itemsControl, expectedFirstIndex, expectedCount);
         }
 
-        [Fact]
-        public void Scrolls_Down_To_Index()
+        [Theory]
+        [InlineData(0d, 11, 10)]
+        [InlineData(0.5d, 6, 20)]
+        public void Scrolls_Down_To_Index(double bufferFactor, int expectedFirstIndex, int expectedCount)
         {
             using var app = App();
-            var (target, scroll, itemsControl) = CreateTarget();
+            var (target, scroll, itemsControl) = CreateTarget(bufferFactor: bufferFactor);
 
             target.ScrollIntoView(20);
 
-            AssertRealizedItems(target, itemsControl, 11, 10);
+            AssertRealizedItems(target, itemsControl, expectedFirstIndex, expectedCount);
         }
 
-        [Fact]
-        public void Scrolls_Up_To_Index()
+        [Theory]
+        [InlineData(0d, 90, 20, 10)]
+        [InlineData(0.5d, 80, 15, 20)]
+        public void Scrolls_Up_To_Index(double bufferFactor, int firstRealizedIndex, int expectedFirstIndex, int expectedCount)
         {
             using var app = App();
-            var (target, scroll, itemsControl) = CreateTarget();
+            var (target, scroll, itemsControl) = CreateTarget(bufferFactor:bufferFactor);
 
             scroll.ScrollToEnd();
             Layout(target);
 
-            Assert.Equal(90, target.FirstRealizedIndex);
+            Assert.Equal(firstRealizedIndex, target.FirstRealizedIndex);
 
             target.ScrollIntoView(20);
 
-            AssertRealizedItems(target, itemsControl, 20, 10);
+            AssertRealizedItems(target, itemsControl, expectedFirstIndex, expectedCount);
         }
 
-        [Fact]
-        public void Scrolling_Up_To_Index_Does_Not_Create_A_Page_Of_Unrealized_Elements()
+        [Theory]
+        [InlineData(0d, 11)]
+        [InlineData(0.5d, 21)]
+        public void Scrolling_Up_To_Index_Does_Not_Create_A_Page_Of_Unrealized_Elements(double bufferFactor, int expectedCount)
         {
             using var app = App();
-            var (target, scroll, itemsControl) = CreateTarget();
+            var (target, scroll, itemsControl) = CreateTarget(bufferFactor:bufferFactor);
 
             scroll.ScrollToEnd();
             Layout(target);
             target.ScrollIntoView(20);
 
-            Assert.Equal(11, target.Children.Count);
-        }
-
-        [Fact]
-        public void Creates_Elements_On_Item_Insert_1()
+            Assert.Equal(expectedCount, target.Children.Count);
+        }
+
+        [Theory]
+        [InlineData(0d, 
+            10, 
+            11, 
+            "-1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10", 
+            10)]
+        [InlineData(0.5d,
+            20,
+            21,
+            "-1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20",
+            20)]
+        public void Creates_Elements_On_Item_Insert_1(double bufferFactor, 
+            int firstCount,
+            int secondCount, 
+            string indexesRaw, 
+            int thirdCount)
         {
             using var app = App();
-            var (target, _, itemsControl) = CreateTarget();
+            var (target, _, itemsControl) = CreateTarget(bufferFactor:bufferFactor);
             var items = (IList)itemsControl.ItemsSource!;
 
-            Assert.Equal(10, target.GetRealizedElements().Count);
+            Assert.Equal(firstCount, target.GetRealizedElements().Count);
 
             items.Insert(0, "new");
 
-            Assert.Equal(11, target.GetRealizedElements().Count);
+            Assert.Equal(secondCount, target.GetRealizedElements().Count);
 
             var indexes = GetRealizedIndexes(target, itemsControl);
 
             // Blank space inserted in realized elements and subsequent indexes updated.
-            Assert.Equal(new[] { -1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }, indexes);
+            Assert.Equal(indexesRaw.Split(", ").Select(Int32.Parse).ToArray(), indexes);
 
             var elements = target.GetRealizedElements().ToList();
             Layout(target);
@@ -162,7 +193,7 @@ namespace Avalonia.Controls.UnitTests
             indexes = GetRealizedIndexes(target, itemsControl);
 
             // After layout an element for the new element is created.
-            Assert.Equal(Enumerable.Range(0, 10), indexes);
+            Assert.Equal(Enumerable.Range(0, thirdCount), indexes);
 
             // But apart from the new element and the removed last element, all existing elements
             // should be the same.
@@ -171,23 +202,37 @@ namespace Avalonia.Controls.UnitTests
             Assert.Equal(elements, target.GetRealizedElements());
         }
 
-        [Fact]
-        public void Creates_Elements_On_Item_Insert_2()
+        [Theory]
+        [InlineData(0d,
+            10,
+            11,
+            "0, 1, -1, 3, 4, 5, 6, 7, 8, 9, 10",
+            10)]
+        [InlineData(0.5d,
+            20,
+            21,
+            "0, 1, -1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20",
+            20)]
+        public void Creates_Elements_On_Item_Insert_2(double bufferFactor,
+            int firstCount,
+            int secondCount,
+            string indexesRaw,
+            int thirdCount)
         {
             using var app = App();
-            var (target, _, itemsControl) = CreateTarget();
+            var (target, _, itemsControl) = CreateTarget(bufferFactor:bufferFactor);
             var items = (IList)itemsControl.ItemsSource!;
 
-            Assert.Equal(10, target.GetRealizedElements().Count);
+            Assert.Equal(firstCount, target.GetRealizedElements().Count);
 
             items.Insert(2, "new");
 
-            Assert.Equal(11, target.GetRealizedElements().Count);
+            Assert.Equal(secondCount, target.GetRealizedElements().Count);
 
             var indexes = GetRealizedIndexes(target, itemsControl);
 
             // Blank space inserted in realized elements and subsequent indexes updated.
-            Assert.Equal(new[] { 0, 1, -1, 3, 4, 5, 6, 7, 8, 9, 10 }, indexes);
+            Assert.Equal(indexesRaw.Split(", ").Select(Int32.Parse).ToArray(), indexes);
 
             var elements = target.GetRealizedElements().ToList();
             Layout(target);
@@ -195,7 +240,7 @@ namespace Avalonia.Controls.UnitTests
             indexes = GetRealizedIndexes(target, itemsControl);
 
             // After layout an element for the new element is created.
-            Assert.Equal(Enumerable.Range(0, 10), indexes);
+            Assert.Equal(Enumerable.Range(0, thirdCount), indexes);
 
             // But apart from the new element and the removed last element, all existing elements
             // should be the same.
@@ -204,8 +249,10 @@ namespace Avalonia.Controls.UnitTests
             Assert.Equal(elements, target.GetRealizedElements());
         }
 
-        [Fact]
-        public void Updates_Elements_On_Item_Moved()
+        [Theory]
+        [InlineData(0d)]
+        [InlineData(0.5d)]
+        public void Updates_Elements_On_Item_Moved(double bufferFactor)
         {
             // Arrange
 
@@ -215,7 +262,7 @@ namespace Avalonia.Controls.UnitTests
                 .Range(0, 100)
                 .Select(x => $"Item {x}"));
 
-            var (target, _, itemsControl) = CreateTarget(items: actualItems);
+            var (target, _, itemsControl) = CreateTarget(items: actualItems, bufferFactor:bufferFactor);
 
             var expectedRealizedElementContents = new[] { 1, 2, 0, 3, 4, 5, 6, 7, 8, 9 }
                 .Select(x => $"Item {x}");
@@ -235,8 +282,10 @@ namespace Avalonia.Controls.UnitTests
             Assert.Equivalent(expectedRealizedElementContents, actualRealizedElementContents);
         }
 
-        [Fact]
-        public void Updates_Elements_On_Item_Range_Moved()
+        [Theory]
+        [InlineData(0d)]
+        [InlineData(0.5d)]
+        public void Updates_Elements_On_Item_Range_Moved(double bufferFactor)
         {
             // Arrange
 
@@ -246,7 +295,7 @@ namespace Avalonia.Controls.UnitTests
                 .Range(0, 100)
                 .Select(x => $"Item {x}"));
 
-            var (target, _, itemsControl) = CreateTarget(items: actualItems);
+            var (target, _, itemsControl) = CreateTarget(items: actualItems, bufferFactor: bufferFactor);
 
             var expectedRealizedElementContents = new[] { 2, 0, 1, 3, 4, 5, 6, 7, 8, 9 }
                 .Select(x => $"Item {x}");
@@ -266,14 +315,16 @@ namespace Avalonia.Controls.UnitTests
             Assert.Equivalent(expectedRealizedElementContents, actualRealizedElementContents);
         }
 
-        [Fact]
-        public void Updates_Elements_On_Item_Remove()
+        [Theory]
+        [InlineData(0d, 10, 9)]
+        [InlineData(0.5d, 20, 19)]
+        public void Updates_Elements_On_Item_Remove(double bufferFactor, int firstCount, int secondCount)
         {
             using var app = App();
-            var (target, _, itemsControl) = CreateTarget();
+            var (target, _, itemsControl) = CreateTarget(bufferFactor: bufferFactor);
             var items = (IList)itemsControl.ItemsSource!;
 
-            Assert.Equal(10, target.GetRealizedElements().Count);
+            Assert.Equal(firstCount, target.GetRealizedElements().Count);
 
             var toRecycle = target.GetRealizedElements().ElementAt(2);
             items.RemoveAt(2);
@@ -281,7 +332,7 @@ namespace Avalonia.Controls.UnitTests
             var indexes = GetRealizedIndexes(target, itemsControl);
 
             // Item removed from realized elements and subsequent row indexes updated.
-            Assert.Equal(Enumerable.Range(0, 9), indexes);
+            Assert.Equal(Enumerable.Range(0, secondCount), indexes);
 
             var elements = target.GetRealizedElements().ToList();
             Layout(target);
@@ -289,21 +340,23 @@ namespace Avalonia.Controls.UnitTests
             indexes = GetRealizedIndexes(target, itemsControl);
 
             // After layout an element for the newly visible last row is created and indexes updated.
-            Assert.Equal(Enumerable.Range(0, 10), indexes);
+            Assert.Equal(Enumerable.Range(0, firstCount), indexes);
 
             // And the removed row should now have been recycled as the last row.
             elements.Add(toRecycle);
             Assert.Equal(elements, target.GetRealizedElements());
         }
 
-        [Fact]
-        public void Updates_Elements_On_Item_Replace()
+        [Theory]
+        [InlineData(0d, 10, "0, 1, -1, 3, 4, 5, 6, 7, 8, 9")]
+        [InlineData(0.5d, 20, "0, 1, -1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19")]
+        public void Updates_Elements_On_Item_Replace(double bufferFactor, int firstCount, string indexesRaw)
         {
             using var app = App();
-            var (target, _, itemsControl) = CreateTarget();
+            var (target, _, itemsControl) = CreateTarget(bufferFactor: bufferFactor);
             var items = (ObservableCollection<string>)itemsControl.ItemsSource!;
 
-            Assert.Equal(10, target.GetRealizedElements().Count);
+            Assert.Equal(firstCount, target.GetRealizedElements().Count);
 
             var toReplace = target.GetRealizedElements().ElementAt(2);
             items[2] = "new";
@@ -315,24 +368,26 @@ namespace Avalonia.Controls.UnitTests
             var indexes = GetRealizedIndexes(target, itemsControl);
 
             // Item removed from realized elements at old position and space inserted at new position.
-            Assert.Equal(new[] { 0, 1, -1, 3, 4, 5, 6, 7, 8, 9 }, indexes);
+            Assert.Equal(indexesRaw.Split(", ").Select(Int32.Parse).ToArray(), indexes);
 
             Layout(target);
 
             indexes = GetRealizedIndexes(target, itemsControl);
 
             // After layout the missing container should have been created.
-            Assert.Equal(Enumerable.Range(0, 10), indexes);
+            Assert.Equal(Enumerable.Range(0, firstCount), indexes);
         }
 
-        [Fact]
-        public void Updates_Elements_On_Item_Move()
+        [Theory]
+        [InlineData(0d, 10, "0, 1, 2, 3, 4, 5, -1, 7, 8, 9")]
+        [InlineData(0.5d, 20, "0, 1, 2, 3, 4, 5, -1, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19")]
+        public void Updates_Elements_On_Item_Move(double bufferFactor, int firstCount, string indexesRaw)
         {
             using var app = App();
-            var (target, _, itemsControl) = CreateTarget();
+            var (target, _, itemsControl) = CreateTarget(bufferFactor:bufferFactor);
             var items = (ObservableCollection<string>)itemsControl.ItemsSource!;
 
-            Assert.Equal(10, target.GetRealizedElements().Count);
+            Assert.Equal(firstCount, target.GetRealizedElements().Count);
 
             var toMove = target.GetRealizedElements().ElementAt(2);
             items.Move(2, 6);
@@ -344,22 +399,24 @@ namespace Avalonia.Controls.UnitTests
             var indexes = GetRealizedIndexes(target, itemsControl);
 
             // Item removed from realized elements at old position and space inserted at new position.
-            Assert.Equal(new[] { 0, 1, 2, 3, 4, 5, -1, 7, 8, 9 }, indexes);
+            Assert.Equal(indexesRaw.Split(", ").Select(Int32.Parse).ToArray(), indexes);
 
             Layout(target);
 
             indexes = GetRealizedIndexes(target, itemsControl);
 
             // After layout the missing container should have been created.
-            Assert.Equal(Enumerable.Range(0, 10), indexes);
+            Assert.Equal(Enumerable.Range(0, firstCount), indexes);
         }
-
-        [Fact]
-        public void Removes_Control_Items_From_Panel_On_Item_Remove()
+       
+        [Theory]
+        [InlineData(0d)]
+        [InlineData(0.5d)]
+        public void Removes_Control_Items_From_Panel_On_Item_Remove(double bufferFactor)
         {
             using var app = App();
             var items = new ObservableCollection<Button>(Enumerable.Range(0, 100).Select(x => new Button { Width = 25, Height = 10 }));
-            var (target, scroll, itemsControl) = CreateTarget(items: items, itemTemplate: null);
+            var (target, scroll, itemsControl) = CreateTarget(items: items, itemTemplate: null, bufferFactor:bufferFactor);
 
             Assert.Equal(1000, scroll.Extent.Height);
 
@@ -370,11 +427,13 @@ namespace Avalonia.Controls.UnitTests
             Assert.Null(removed.VisualParent);
         }
 
-        [Fact]
-        public void Does_Not_Recycle_Focused_Element()
+        [Theory]
+        [InlineData(0d)]
+        [InlineData(0.5d)]
+        public void Does_Not_Recycle_Focused_Element(double bufferFactor)
         {
             using var app = App();
-            var (target, scroll, itemsControl) = CreateTarget();
+            var (target, scroll, itemsControl) = CreateTarget(bufferFactor: bufferFactor);
 
             var focused = target.GetRealizedElements().First()!;
             focused.Focusable = true;
@@ -387,11 +446,13 @@ namespace Avalonia.Controls.UnitTests
             Assert.All(target.GetRealizedElements(), x => Assert.False(x!.IsKeyboardFocusWithin));
         }
 
-        [Fact]
-        public void Removing_Item_Of_Focused_Element_Clears_Focus()
+        [Theory]
+        [InlineData(0d)]
+        [InlineData(0.5d)]
+        public void Removing_Item_Of_Focused_Element_Clears_Focus(double bufferFactor)
         {
             using var app = App();
-            var (target, scroll, itemsControl) = CreateTarget();
+            var (target, scroll, itemsControl) = CreateTarget(bufferFactor: bufferFactor);
             var items = (IList)itemsControl.ItemsSource!;
 
             var focused = target.GetRealizedElements().First()!;
@@ -409,11 +470,13 @@ namespace Avalonia.Controls.UnitTests
             Assert.All(target.GetRealizedElements(), x => Assert.NotSame(focused, x));
         }
 
-        [Fact]
-        public void Scrolling_Back_To_Focused_Element_Uses_Correct_Element()
+        [Theory]
+        [InlineData(0d)]
+        [InlineData(0.5d)]
+        public void Scrolling_Back_To_Focused_Element_Uses_Correct_Element(double bufferFactor)
         {
             using var app = App();
-            var (target, scroll, itemsControl) = CreateTarget();
+            var (target, scroll, itemsControl) = CreateTarget(bufferFactor: bufferFactor);
 
             var focused = target.GetRealizedElements().First()!;
             focused.Focusable = true;
@@ -429,11 +492,13 @@ namespace Avalonia.Controls.UnitTests
             Assert.Same(focused, target.GetRealizedElements().First());
         }
 
-        [Fact]
-        public void Focusing_Another_Element_Recycles_Original_Focus_Element()
+        [Theory]
+        [InlineData(0d)]
+        [InlineData(0.5d)]
+        public void Focusing_Another_Element_Recycles_Original_Focus_Element(double bufferFactor)
         {
             using var app = App();
-            var (target, scroll, itemsControl) = CreateTarget();
+            var (target, scroll, itemsControl) = CreateTarget(bufferFactor: bufferFactor);
 
             var originalFocused = target.GetRealizedElements().First()!;
             originalFocused.Focusable = true;
@@ -449,11 +514,13 @@ namespace Avalonia.Controls.UnitTests
             Assert.False(originalFocused.IsVisible);
         }
 
-        [Fact]
-        public void Focused_Element_Losing_Focus_Does_Not_Reset_Selection()
+        [Theory]
+        [InlineData(0d)]
+        [InlineData(0.5d)]
+        public void Focused_Element_Losing_Focus_Does_Not_Reset_Selection(double bufferFactor)
         {
             using var app = App();
-            var (target, scroll, listBox) = CreateTarget<ListBox>(
+            var (target, scroll, listBox) = CreateTarget<ListBox, VirtualizingStackPanel>(
                 styles: new[]
                 {
                     new Style(x => x.OfType<ListBoxItem>())
@@ -463,7 +530,7 @@ namespace Avalonia.Controls.UnitTests
                             new Setter(ListBoxItem.TemplateProperty, ListBoxItemTemplate()),
                         }
                     }
-                });
+                }, bufferFactor: bufferFactor);
 
             listBox.SelectedIndex = 0;
 
@@ -481,36 +548,40 @@ namespace Avalonia.Controls.UnitTests
             Assert.Equal(0, listBox.SelectedIndex);
         }
 
-        [Fact]
-        public void Removing_Range_When_Scrolled_To_End_Updates_Viewport()
+        [Theory]
+        [InlineData(0d, 90, 10, 10)]
+        [InlineData(0.5d, 80, 0, 20)]
+        public void Removing_Range_When_Scrolled_To_End_Updates_Viewport(double bufferFactor, int firstIndex, int secondIndex, int count)
         {
             using var app = App();
             var items = new AvaloniaList<string>(Enumerable.Range(0, 100).Select(x => $"Item {x}"));
-            var (target, scroll, itemsControl) = CreateTarget(items: items);
+            var (target, scroll, itemsControl) = CreateTarget(items: items, bufferFactor: bufferFactor);
 
             scroll.Offset = new Vector(0, 900);
             Layout(target);
 
-            AssertRealizedItems(target, itemsControl, 90, 10);
+            AssertRealizedItems(target, itemsControl, firstIndex, count);
 
             items.RemoveRange(0, 80);
             Layout(target);
 
-            AssertRealizedItems(target, itemsControl, 10, 10);
+            AssertRealizedItems(target, itemsControl, secondIndex, count);
             Assert.Equal(new Vector(0, 100), scroll.Offset);
         }
 
-        [Fact]
-        public void Removing_Range_To_Have_Less_Than_A_Page_Of_Items_When_Scrolled_To_End_Updates_Viewport()
+        [Theory]
+        [InlineData(0d, 90, 10)]
+        [InlineData(0.5d, 80, 20)]
+        public void Removing_Range_To_Have_Less_Than_A_Page_Of_Items_When_Scrolled_To_End_Updates_Viewport(double bufferFactor, int firstIndex, int count)
         {
             using var app = App();
             var items = new AvaloniaList<string>(Enumerable.Range(0, 100).Select(x => $"Item {x}"));
-            var (target, scroll, itemsControl) = CreateTarget(items: items);
+            var (target, scroll, itemsControl) = CreateTarget(items: items, bufferFactor: bufferFactor);
 
             scroll.Offset = new Vector(0, 900);
             Layout(target);
 
-            AssertRealizedItems(target, itemsControl, 90, 10);
+            AssertRealizedItems(target, itemsControl, firstIndex, count);
 
             items.RemoveRange(0, 95);
             Layout(target);
@@ -519,36 +590,40 @@ namespace Avalonia.Controls.UnitTests
             Assert.Equal(new Vector(0, 0), scroll.Offset);
         }
 
-        [Fact]
-        public void Resetting_Collection_To_Have_Less_Items_When_Scrolled_To_End_Updates_Viewport()
+        [Theory]
+        [InlineData(0d, 90, 10, 10)]
+        [InlineData(0.5d, 80,0, 20)]
+        public void Resetting_Collection_To_Have_Less_Items_When_Scrolled_To_End_Updates_Viewport(double bufferFactor, int firstIndex, int secondIndex, int count)
         {
             using var app = App();
             var items = new ResettingCollection(Enumerable.Range(0, 100).Select(x => $"Item {x}"));
-            var (target, scroll, itemsControl) = CreateTarget(items: items);
+            var (target, scroll, itemsControl) = CreateTarget(items: items, bufferFactor: bufferFactor);
 
             scroll.Offset = new Vector(0, 900);
             Layout(target);
 
-            AssertRealizedItems(target, itemsControl, 90, 10);
+            AssertRealizedItems(target, itemsControl, firstIndex, count);
 
             items.Reset(Enumerable.Range(0, 20).Select(x => $"Item {x}"));
             Layout(target);
 
-            AssertRealizedItems(target, itemsControl, 10, 10);
+            AssertRealizedItems(target, itemsControl, secondIndex, count);
             Assert.Equal(new Vector(0, 100), scroll.Offset);
         }
 
-        [Fact]
-        public void Resetting_Collection_To_Have_Less_Than_A_Page_Of_Items_When_Scrolled_To_End_Updates_Viewport()
+        [Theory]
+        [InlineData(0d, 90, 10)]
+        [InlineData(0.5d, 80, 20)]
+        public void Resetting_Collection_To_Have_Less_Than_A_Page_Of_Items_When_Scrolled_To_End_Updates_Viewport(double bufferFactor, int firstIndex, int count)
         {
             using var app = App();
             var items = new ResettingCollection(Enumerable.Range(0, 100).Select(x => $"Item {x}"));
-            var (target, scroll, itemsControl) = CreateTarget(items: items);
+            var (target, scroll, itemsControl) = CreateTarget(items: items, bufferFactor: bufferFactor);
 
             scroll.Offset = new Vector(0, 900);
             Layout(target);
 
-            AssertRealizedItems(target, itemsControl, 90, 10);
+            AssertRealizedItems(target, itemsControl, firstIndex, count);
 
             items.Reset(Enumerable.Range(0, 5).Select(x => $"Item {x}"));
             Layout(target);
@@ -557,8 +632,10 @@ namespace Avalonia.Controls.UnitTests
             Assert.Equal(new Vector(0, 0), scroll.Offset);
         }
 
-        [Fact]
-        public void NthChild_Selector_Works()
+        [Theory]
+        [InlineData(0d, 10, "4,9")]
+        [InlineData(0.5d, 20, "4,9,14,19")]
+        public void NthChild_Selector_Works(double bufferFactor, int count, string indexesRaw)
         {
             using var app = App();
 
@@ -567,16 +644,17 @@ namespace Avalonia.Controls.UnitTests
                 Setters = { new Setter(ListBoxItem.BackgroundProperty, Brushes.Red) },
             };
 
-            var (target, _, _) = CreateTarget(styles: new[] { style });
+            var (target, _, _) = CreateTarget(styles: new[] { style }, bufferFactor: bufferFactor);
             var realized = target.GetRealizedContainers()!.Cast<ContentPresenter>().ToList();
 
-            Assert.Equal(10, realized.Count);
+            Assert.Equal(count, realized.Count);
 
-            for (var i = 0; i < 10; ++i)
+            for (var i = 0; i < count; ++i)
             {
                 var container = realized[i];
                 var index = target.IndexFromContainer(container);
-                var expectedBackground = (i == 4 || i == 9) ? Brushes.Red : null;
+                var redIndexes = indexesRaw.Split(",").Select(Int32.Parse).ToArray();
+                var expectedBackground = redIndexes.Contains(i) ? Brushes.Red : null;
 
                 Assert.Equal(i, index);
                 Assert.Equal(expectedBackground, container.Background);
@@ -584,8 +662,10 @@ namespace Avalonia.Controls.UnitTests
         }
 
         // https://github.com/AvaloniaUI/Avalonia/issues/12838
-        [Fact]
-        public void NthChild_Selector_Works_For_ItemTemplate_Children()
+        [Theory]
+        [InlineData(0d, 10, "4,9")]
+        [InlineData(0.5d, 20, "4,9,14,19")]
+        public void NthChild_Selector_Works_For_ItemTemplate_Children(double bufferFactor, int count, string indexesRaw)
         {
             using var app = App();
 
@@ -594,24 +674,27 @@ namespace Avalonia.Controls.UnitTests
                 Setters = { new Setter(Panel.BackgroundProperty, Brushes.Red) },
             };
 
-            var (target, _, _) = CreateTarget(styles: new[] { style });
+            var (target, _, _) = CreateTarget(styles: new[] { style }, bufferFactor: bufferFactor);
             var realized = target.GetRealizedContainers()!.Cast<ContentPresenter>().ToList();
 
-            Assert.Equal(10, realized.Count);
+            Assert.Equal(count, realized.Count);
 
-            for (var i = 0; i < 10; ++i)
+            for (var i = 0; i < count; ++i)
             {
                 var container = realized[i];
                 var index = target.IndexFromContainer(container);
-                var expectedBackground = (i == 4 || i == 9) ? Brushes.Red : null;
+                var redIndexes = indexesRaw.Split(",").Select(Int32.Parse).ToArray();
+                var expectedBackground = redIndexes.Contains(i) ? Brushes.Red : null;
 
                 Assert.Equal(i, index);
                 Assert.Equal(expectedBackground, ((Canvas)container.Child!).Background);
             }
         }
 
-        [Fact]
-        public void NthLastChild_Selector_Works()
+        [Theory]
+        [InlineData(0d, 10, "0,5")]
+        [InlineData(0.5d, 20, "0,5,10,15")]
+        public void NthLastChild_Selector_Works(double bufferFactor, int count, string indexesRaw)
         {
             using var app = App();
 
@@ -620,16 +703,17 @@ namespace Avalonia.Controls.UnitTests
                 Setters = { new Setter(ListBoxItem.BackgroundProperty, Brushes.Red) },
             };
 
-            var (target, _, _) = CreateTarget(styles: new[] { style });
+            var (target, _, _) = CreateTarget(styles: new[] { style }, bufferFactor: bufferFactor);
             var realized = target.GetRealizedContainers()!.Cast<ContentPresenter>().ToList();
 
-            Assert.Equal(10, realized.Count);
+            Assert.Equal(count, realized.Count);
 
-            for (var i = 0; i < 10; ++i)
+            for (var i = 0; i < count; ++i)
             {
                 var container = realized[i];
                 var index = target.IndexFromContainer(container);
-                var expectedBackground = (i == 0 || i == 5) ? Brushes.Red : null;
+                var redIndexes = indexesRaw.Split(",").Select(Int32.Parse).ToArray();
+                var expectedBackground = redIndexes.Contains(i) ? Brushes.Red : null;
 
                 Assert.Equal(i, index);
                 Assert.Equal(expectedBackground, container.Background);
@@ -637,8 +721,10 @@ namespace Avalonia.Controls.UnitTests
         }
 
         // https://github.com/AvaloniaUI/Avalonia/issues/12838
-        [Fact]
-        public void NthLastChild_Selector_Works_For_ItemTemplate_Children()
+        [Theory]
+        [InlineData(0d, 10, "0,5")]
+        [InlineData(0.5d, 20, "0,5,10,15")]
+        public void NthLastChild_Selector_Works_For_ItemTemplate_Children(double bufferFactor, int count, string indexesRaw)
         {
             using var app = App();
 
@@ -647,27 +733,30 @@ namespace Avalonia.Controls.UnitTests
                 Setters = { new Setter(Panel.BackgroundProperty, Brushes.Red) },
             };
 
-            var (target, _, _) = CreateTarget(styles: new[] { style });
+            var (target, _, _) = CreateTarget(styles: new[] { style }, bufferFactor: bufferFactor);
             var realized = target.GetRealizedContainers()!.Cast<ContentPresenter>().ToList();
 
-            Assert.Equal(10, realized.Count);
+            Assert.Equal(count, realized.Count);
 
-            for (var i = 0; i < 10; ++i)
+            for (var i = 0; i < count; ++i)
             {
                 var container = realized[i];
                 var index = target.IndexFromContainer(container);
-                var expectedBackground = (i == 0 || i == 5) ? Brushes.Red : null;
+                var redIndexes = indexesRaw.Split(",").Select(Int32.Parse).ToArray();
+                var expectedBackground = redIndexes.Contains(i) ? Brushes.Red : null;
 
                 Assert.Equal(i, index);
                 Assert.Equal(expectedBackground, ((Canvas)container.Child!).Background);
             }
         }
 
-        [Fact]
-        public void ContainerPrepared_Is_Raised_When_Scrolling()
+        [Theory]
+        [InlineData(0d, 10)]
+        [InlineData(0.5d, 15)]
+        public void ContainerPrepared_Is_Raised_When_Scrolling(double bufferFactor, int expectedRaised)
         {
             using var app = App();
-            var (target, scroll, itemsControl) = CreateTarget();
+            var (target, scroll, itemsControl) = CreateTarget(bufferFactor: bufferFactor);
             var raised = 0;
 
             itemsControl.ContainerPrepared += (s, e) => ++raised;
@@ -675,14 +764,16 @@ namespace Avalonia.Controls.UnitTests
             scroll.Offset = new Vector(0, 200);
             Layout(target);
 
-            Assert.Equal(10, raised);
+            Assert.Equal(expectedRaised, raised);
         }
 
-        [Fact]
-        public void ContainerClearing_Is_Raised_When_Scrolling()
+        [Theory]
+        [InlineData(0d, 10)]
+        [InlineData(0.5d, 15)]
+        public void ContainerClearing_Is_Raised_When_Scrolling(double bufferFactor, int expectedRaised)
         {
             using var app = App();
-            var (target, scroll, itemsControl) = CreateTarget();
+            var (target, scroll, itemsControl) = CreateTarget(bufferFactor: bufferFactor);
             var raised = 0;
 
             itemsControl.ContainerClearing += (s, e) => ++raised;
@@ -690,14 +781,16 @@ namespace Avalonia.Controls.UnitTests
             scroll.Offset = new Vector(0, 200);
             Layout(target);
 
-            Assert.Equal(10, raised);
+            Assert.Equal(expectedRaised, raised);
         }
 
-        [Fact]
-        public void ContainerIndexChanged_Is_Raised_On_Insert()
+        [Theory]
+        [InlineData(0d, 9)]
+        [InlineData(0.5d, 19)]
+        public void ContainerIndexChanged_Is_Raised_On_Insert(double bufferFactor, int expectedRaised)
         {
             using var app = App();
-            var (target, scroll, itemsControl) = CreateTarget();
+            var (target, scroll, itemsControl) = CreateTarget(bufferFactor: bufferFactor);
             var items = (IList)itemsControl.ItemsSource!;
             var raised = 0;
             var index = 1;
@@ -711,17 +804,18 @@ namespace Avalonia.Controls.UnitTests
 
             items.Insert(index, "new");
 
-            Assert.Equal(9, raised);
+            Assert.Equal(expectedRaised, raised);
         }
 
-        [Fact]
-        public void ContainerIndexChanged_Is_Raised_When_Item_Inserted_Before_Realized_Elements()
+        [Theory]
+        [InlineData(0d, 10, 20)]
+        [InlineData(0.5d, 20, 15)]
+        public void ContainerIndexChanged_Is_Raised_When_Item_Inserted_Before_Realized_Elements(double bufferFactor, int expectedRaised, int index)
         {
             using var app = App();
-            var (target, scroll, itemsControl) = CreateTarget();
+            var (target, scroll, itemsControl) = CreateTarget(bufferFactor: bufferFactor);
             var items = (IList)itemsControl.ItemsSource!;
             var raised = 0;
-            var index = 20;
 
             itemsControl.ContainerIndexChanged += (s, e) =>
             {
@@ -735,14 +829,16 @@ namespace Avalonia.Controls.UnitTests
 
             items.Insert(10, "new");
 
-            Assert.Equal(10, raised);
+            Assert.Equal(expectedRaised, raised);
         }
 
-        [Fact]
-        public void ContainerIndexChanged_Is_Raised_On_Remove()
+        [Theory]
+        [InlineData(0d, 8)]
+        [InlineData(0.5d, 18)]
+        public void ContainerIndexChanged_Is_Raised_On_Remove(double bufferFactor, int expectedRaised)
         {
             using var app = App();
-            var (target, scroll, itemsControl) = CreateTarget();
+            var (target, scroll, itemsControl) = CreateTarget(bufferFactor: bufferFactor);
             var items = (IList)itemsControl.ItemsSource!;
             var raised = 0;
             var index = 1;
@@ -756,17 +852,18 @@ namespace Avalonia.Controls.UnitTests
 
             items.RemoveAt(index);
 
-            Assert.Equal(8, raised);
+            Assert.Equal(expectedRaised, raised);
         }
 
-        [Fact]
-        public void ContainerIndexChanged_Is_Raised_When_Item_Removed_Before_Realized_Elements()
+        [Theory]
+        [InlineData(0d, 10, 20)]
+        [InlineData(0.5d, 20, 15)]
+        public void ContainerIndexChanged_Is_Raised_When_Item_Removed_Before_Realized_Elements(double bufferFactor, int expectedRaised, int index)
         {
             using var app = App();
-            var (target, scroll, itemsControl) = CreateTarget();
+            var (target, scroll, itemsControl) = CreateTarget(bufferFactor: bufferFactor);
             var items = (IList)itemsControl.ItemsSource!;
             var raised = 0;
-            var index = 20;
 
             itemsControl.ContainerIndexChanged += (s, e) =>
             {
@@ -781,14 +878,16 @@ namespace Avalonia.Controls.UnitTests
 
             items.RemoveAt(10);
 
-            Assert.Equal(10, raised);
+            Assert.Equal(expectedRaised, raised);
         }
 
-        [Fact]
-        public void Fires_Correct_Container_Lifecycle_Events_On_Replace()
+        [Theory]
+        [InlineData(0d)]
+        [InlineData(0.5d)]
+        public void Fires_Correct_Container_Lifecycle_Events_On_Replace(double bufferFactor)
         {
             using var app = App();
-            var (target, scroll, itemsControl) = CreateTarget();
+            var (target, scroll, itemsControl) = CreateTarget(bufferFactor: bufferFactor);
             var items = (IList)itemsControl.ItemsSource!;
             var events = new List<string>();
 
@@ -812,15 +911,17 @@ namespace Avalonia.Controls.UnitTests
             events.Clear();
         }
 
-        [Fact]
-        public void Scrolling_Down_With_Larger_Element_Does_Not_Cause_Jump_And_Arrives_At_End()
+        [Theory]
+        [InlineData(0d)]
+        [InlineData(0.5d)]
+        public void Scrolling_Down_With_Larger_Element_Does_Not_Cause_Jump_And_Arrives_At_End(double bufferFactor)
         {
             using var app = App();
 
             var items = Enumerable.Range(0, 1000).Select(x => new ItemWithHeight(x)).ToList();
             items[20].Height = 200;
 
-            var (target, scroll, itemsControl) = CreateTarget(items: items, itemTemplate: CanvasWithHeightTemplate);
+            var (target, scroll, itemsControl) = CreateTarget(items: items, itemTemplate: CanvasWithHeightTemplate, bufferFactor: bufferFactor);
 
             var index = target.FirstRealizedIndex;
 
@@ -841,15 +942,17 @@ namespace Avalonia.Controls.UnitTests
             }
         }
 
-        [Fact]
-        public void Scrolling_Up_To_Larger_Element_Does_Not_Cause_Jump()
+        [Theory]
+        [InlineData(0d)]
+        [InlineData(0.5d)]
+        public void Scrolling_Up_To_Larger_Element_Does_Not_Cause_Jump(double bufferFactor)
         {
             using var app = App();
 
             var items = Enumerable.Range(0, 100).Select(x => new ItemWithHeight(x)).ToList();
             items[20].Height = 200;
 
-            var (target, scroll, itemsControl) = CreateTarget(items: items, itemTemplate: CanvasWithHeightTemplate);
+            var (target, scroll, itemsControl) = CreateTarget(items: items, itemTemplate: CanvasWithHeightTemplate, bufferFactor: bufferFactor);
 
             // Scroll past the larger element.
             scroll.Offset = new Vector(0, 600);
@@ -871,15 +974,26 @@ namespace Avalonia.Controls.UnitTests
             }
         }
 
-        [Fact]
-        public void Scrolling_Up_To_Smaller_Element_Does_Not_Cause_Jump()
+        [Theory]
+        [InlineData(0d)]
+        [InlineData(0.5d)]
+        public void Scrolling_Up_To_Smaller_Element_Does_Not_Cause_Jump(double bufferFactor)
         {
             using var app = App();
 
             var items = Enumerable.Range(0, 100).Select(x => new ItemWithHeight(x, 30)).ToList();
             items[20].Height = 25;
 
-            var (target, scroll, itemsControl) = CreateTarget(items: items, itemTemplate: CanvasWithHeightTemplate);
+            var (target, scroll, itemsControl) = CreateTarget(items: items, 
+                itemTemplate: CanvasWithHeightTemplate, 
+                bufferFactor: bufferFactor);
+
+            var additionalItemsCount = bufferFactor == 0d
+                ? 1
+                // buffer factor of 0.5 and 7 visible items => will be rounded up to 4
+                // => when we scroll up and are near the _extended_ viewport,
+                // 4 additional items will be inserted above the current viewport
+                : Math.Round(target.Children.Count * target.CacheLength, MidpointRounding.AwayFromZero);
 
             // Scroll past the larger element.
             scroll.Offset = new Vector(0, 25 * items[0].Height);
@@ -900,19 +1014,21 @@ namespace Avalonia.Controls.UnitTests
                     target.FirstRealizedIndex <= index,
                     $"{target.FirstRealizedIndex} is not less than {index}");
                 Assert.True(
-                    index - target.FirstRealizedIndex <= 1,
+                    index - target.FirstRealizedIndex <= additionalItemsCount,
                     $"FirstIndex changed from {index} to {target.FirstRealizedIndex}");
 
                 index = target.FirstRealizedIndex;
             }
         }
 
-        [Fact]
-        public void Does_Not_Throw_When_Estimating_Viewport_With_Ancestor_Margin()
+        [Theory]
+        [InlineData(0d)]
+        [InlineData(0.5d)]
+        public void Does_Not_Throw_When_Estimating_Viewport_With_Ancestor_Margin(double bufferFactor)
         {
             // Issue #11272
             using var app = App();
-            var (_, _, itemsControl) = CreateUnrootedTarget<ItemsControl>();
+            var (_, _, itemsControl) = CreateUnrootedTarget<ItemsControl>(bufferFactor: bufferFactor);
             var container = new Decorator { Margin = new Thickness(100) };
             var root = new TestRoot(true, container);
 
@@ -923,17 +1039,19 @@ namespace Avalonia.Controls.UnitTests
             root.LayoutManager.ExecuteLayoutPass();
         }
 
-        [Fact]
-        public void Supports_Null_Recycle_Key_When_Scrolling()
+        [Theory]
+        [InlineData(0d, 20)]
+        [InlineData(0.5d, 200)]
+        public void Supports_Null_Recycle_Key_When_Scrolling(double bufferFactor, int offset)
         {
             using var app = App();
-            var (_, scroll, itemsControl) = CreateUnrootedTarget<NonRecyclingItemsControl>();
+            var (_, scroll, itemsControl) = CreateUnrootedTarget<NonRecyclingItemsControl>(bufferFactor: bufferFactor);
             var root = CreateRoot(itemsControl);
 
             root.LayoutManager.ExecuteInitialLayoutPass();
 
             var firstItem = itemsControl.ContainerFromIndex(0)!;
-            scroll.Offset = new(0, 20);
+            scroll.Offset = new(0, offset);
 
             Layout(itemsControl);
 
@@ -942,11 +1060,13 @@ namespace Avalonia.Controls.UnitTests
             Assert.DoesNotContain(firstItem, itemsControl.ItemsPanelRoot!.Children);
         }
 
-        [Fact]
-        public void Supports_Null_Recycle_Key_When_Clearing_Items()
+        [Theory]
+        [InlineData(0d)]
+        [InlineData(0.5d)]
+        public void Supports_Null_Recycle_Key_When_Clearing_Items(double bufferFactor)
         {
             using var app = App();
-            var (_, _, itemsControl) = CreateUnrootedTarget<NonRecyclingItemsControl>();
+            var (_, _, itemsControl) = CreateUnrootedTarget<NonRecyclingItemsControl>(bufferFactor: bufferFactor);
             var root = CreateRoot(itemsControl);
 
             root.LayoutManager.ExecuteInitialLayoutPass();
@@ -961,11 +1081,13 @@ namespace Avalonia.Controls.UnitTests
             Assert.Empty(itemsControl.ItemsPanelRoot!.Children);
         }
 
-        [Fact]
-        public void ScrollIntoView_On_Effectively_Invisible_Panel_Does_Not_Create_Ghost_Elements()
+        [Theory]
+        [InlineData(0d)]
+        [InlineData(0.5d)]
+        public void ScrollIntoView_On_Effectively_Invisible_Panel_Does_Not_Create_Ghost_Elements(double bufferFactor)
         {
             var items = new[] { "foo", "bar", "baz" };
-            var (target, _, itemsControl) = CreateUnrootedTarget<ItemsControl>(items: items);
+            var (target, _, itemsControl) = CreateUnrootedTarget<ItemsControl>(items: items, bufferFactor: bufferFactor);
             var container = new Decorator { Margin = new Thickness(100), Child = itemsControl };
             var root = new TestRoot(true, container);
 
@@ -996,11 +1118,13 @@ namespace Avalonia.Controls.UnitTests
         }
 
         // https://github.com/AvaloniaUI/Avalonia/issues/10968
-        [Fact]
-        public void Does_Not_Realize_Items_If_Self_Outside_Viewport()
+        [Theory]
+        [InlineData(0d)]
+        [InlineData(0.5d)]
+        public void Does_Not_Realize_Items_If_Self_Outside_Viewport(double bufferFactor)
         {
             using var app = App();
-            var (panel, _, itemsControl) = CreateUnrootedTarget<ItemsControl>();
+            var (panel, _, itemsControl) = CreateUnrootedTarget<ItemsControl>(bufferFactor: bufferFactor);
             itemsControl.Margin = new Thickness(0.0, 200.0, 0.0, 0.0);
 
             var scrollContentPresenter = new ScrollContentPresenter
@@ -1023,8 +1147,14 @@ namespace Avalonia.Controls.UnitTests
             Assert.Equal(1, panel.VisualChildren.Count);
         }
 
-        [Fact]
-        public void Alternating_Backgrounds_Should_Be_Correct_After_Scrolling()
+        [Theory]
+        [InlineData(0d, 0, 8, 1,9)]
+        [InlineData(0.5d, 0, 17, 0, 17)]
+        public void Alternating_Backgrounds_Should_Be_Correct_After_Scrolling(double bufferFactor, 
+            int firstIndex1, 
+            int lastIndex1,
+            int firstIndex2,
+            int lastIndex2)
         {
             // Issue #12381.
             static void AssertColors(VirtualizingStackPanel target)
@@ -1059,7 +1189,7 @@ namespace Avalonia.Controls.UnitTests
                     Setters = { new Setter(ListBoxItem.BackgroundProperty, Brushes.Red) },
                 },
             };
-            var (target, scroll, itemsControl) = CreateUnrootedTarget<ListBox>();
+            var (target, scroll, itemsControl) = CreateUnrootedTarget<ListBox>(bufferFactor: bufferFactor);
 
             // We need to display an odd number of items to reproduce the issue.
             var root = CreateRoot(itemsControl, clientSize: new(100, 90), styles: styles);
@@ -1069,47 +1199,51 @@ namespace Avalonia.Controls.UnitTests
                 .Cast<ListBoxItem>()
                 .ToList();
 
-            Assert.Equal(0, target.FirstRealizedIndex);
-            Assert.Equal(8, target.LastRealizedIndex);
+            Assert.Equal(firstIndex1, target.FirstRealizedIndex);
+            Assert.Equal(lastIndex1, target.LastRealizedIndex);
             AssertColors(target);
 
             scroll.Offset = new Vector(0, 10);
             target.UpdateLayout();
 
-            Assert.Equal(1, target.FirstRealizedIndex);
-            Assert.Equal(9, target.LastRealizedIndex);
+            Assert.Equal(firstIndex2, target.FirstRealizedIndex);
+            Assert.Equal(lastIndex2, target.LastRealizedIndex);
             AssertColors(target);
         }
 
-        [Fact]
-        public void Inserting_Item_Before_Viewport_Preserves_FirstRealizedIndex()
+        [Theory]
+        [InlineData(0d, 20)]
+        [InlineData(0.5d, 15)]
+        public void Inserting_Item_Before_Viewport_Preserves_FirstRealizedIndex(double bufferFactor, int firstIndex)
         {
             // Issue #12744
             using var app = App();
-            var (target, scroll, itemsControl) = CreateTarget();
+            var (target, scroll, itemsControl) = CreateTarget(bufferFactor: bufferFactor);
             var items = (IList)itemsControl.ItemsSource!;
 
             // Scroll down 20 items.
             scroll.Offset = new Vector(0, 200);
             target.UpdateLayout();
-            Assert.Equal(20, target.FirstRealizedIndex);
+            Assert.Equal(firstIndex, target.FirstRealizedIndex);
 
             // Insert an item at the beginning.
             items.Insert(0, "New Item");
             target.UpdateLayout();
 
             // The first realized index should still be 20 as the scroll should be unchanged.
-            Assert.Equal(20, target.FirstRealizedIndex);
+            Assert.Equal(firstIndex, target.FirstRealizedIndex);
             Assert.Equal(new(0, 200), scroll.Offset);
         }
 
-        [Fact]
-        public void Can_Bind_Item_IsVisible()
+        [Theory]
+        [InlineData(0d)]
+        [InlineData(0.5d)]
+        public void Can_Bind_Item_IsVisible(double bufferFactor)
         {
             using var app = App();
             var style = CreateIsVisibleBindingStyle();
             var items = Enumerable.Range(0, 100).Select(x => new ItemWithIsVisible(x)).ToList();
-            var (target, scroll, itemsControl) = CreateTarget(items: items, styles: new[] { style });
+            var (target, scroll, itemsControl) = CreateTarget(items: items, styles: new[] { style }, bufferFactor: bufferFactor);
             var container = target.ContainerFromIndex(2)!;
 
             Assert.True(container.IsVisible);
@@ -1124,13 +1258,15 @@ namespace Avalonia.Controls.UnitTests
             Assert.Equal(20, target.ContainerFromIndex(3)!.Bounds.Top);
         }
 
-        [Fact]
-        public void IsVisible_Binding_Persists_After_Scrolling()
+        [Theory]
+        [InlineData(0d)]
+        [InlineData(0.5d)]
+        public void IsVisible_Binding_Persists_After_Scrolling(double bufferFactor)
         {
             using var app = App();
             var style = CreateIsVisibleBindingStyle();
             var items = Enumerable.Range(0, 100).Select(x => new ItemWithIsVisible(x)).ToList();
-            var (target, scroll, itemsControl) = CreateTarget(items: items, styles: new[] { style });
+            var (target, scroll, itemsControl) = CreateTarget(items: items, styles: new[] { style }, bufferFactor: bufferFactor);
             var container = target.ContainerFromIndex(2)!;
 
             Assert.True(container.IsVisible);
@@ -1147,13 +1283,16 @@ namespace Avalonia.Controls.UnitTests
             Assert.False(container.IsVisible);
         }
 
-        [Fact]
-        public void Recycling_A_Hidden_Control_Shows_It()
+        [Theory]
+        [InlineData(0d)]
+        [InlineData(0.5d)]
+        public void Recycling_A_Hidden_Control_Shows_It(double bufferFactor)
         {
             using var app = App();
             var style = CreateIsVisibleBindingStyle();
-            var items = Enumerable.Range(0, 3).Select(x => new ItemWithIsVisible(x)).ToList();
-            var (target, scroll, itemsControl) = CreateTarget(items: items, styles: new[] { style });
+            var itemsList = Enumerable.Range(0, 3).Select(x => new ItemWithIsVisible(x)).ToList();
+            var items = new ObservableCollection<ItemWithIsVisible>(itemsList);
+            var (target, scroll, itemsControl) = CreateTarget(items: items, styles: new[] { style }, bufferFactor: bufferFactor);
             var container = target.ContainerFromIndex(2)!;
 
             Assert.True(container.IsVisible);
@@ -1171,8 +1310,10 @@ namespace Avalonia.Controls.UnitTests
             Assert.True(container.IsVisible);
         }
 
-        [Fact]
-        public void ScrollIntoView_With_TargetRect_Outside_Viewport_Should_Scroll_To_Item()
+        [Theory]
+        [InlineData(0d)]
+        [InlineData(0.5d)]
+        public void ScrollIntoView_With_TargetRect_Outside_Viewport_Should_Scroll_To_Item(double bufferFactor)
         {
             using var app = App();
             var items = Enumerable.Range(0, 101).Select(x => new ItemWithHeight(x, x * 100 + 1));
@@ -1194,7 +1335,8 @@ namespace Avalonia.Controls.UnitTests
                             new Setter(ScrollViewer.HorizontalScrollBarVisibilityProperty, ScrollBarVisibility.Visible),
                         }
                     }
-                });
+                },
+                bufferFactor: bufferFactor);
             itemsControl.ContainerPrepared += (_, ev) =>
             {
                 ev.Container.AddHandler(Control.RequestBringIntoViewEvent, (_, e) =>
@@ -1209,14 +1351,16 @@ namespace Avalonia.Controls.UnitTests
             Assert.Equal(9901, scroll.Offset.X);
         }
 
-        [Fact]
-        public void ScrollIntoView_Correctly_Scrolls_Down_To_A_Page_Of_Smaller_Items()
+        [Theory]
+        [InlineData(0d, 10, 10)]
+        [InlineData(0.5d, 5, 15)]
+        public void ScrollIntoView_Correctly_Scrolls_Down_To_A_Page_Of_Smaller_Items(double bufferFactor, int firstIndex, int count)
         {
             using var app = App();
 
             // First 10 items have height of 20, next 10 have height of 10.
             var items = Enumerable.Range(0, 20).Select(x => new ItemWithHeight(x, ((29 - x) / 10) * 10));
-            var (target, scroll, itemsControl) = CreateTarget(items: items, itemTemplate: CanvasWithHeightTemplate);
+            var (target, scroll, itemsControl) = CreateTarget(items: items, itemTemplate: CanvasWithHeightTemplate, bufferFactor: bufferFactor);
 
             // Scroll the last item into view.
             target.ScrollIntoView(19);
@@ -1232,17 +1376,19 @@ namespace Avalonia.Controls.UnitTests
             Assert.Equal(new Vector(0, 290), scroll.Offset);
 
             // Items 10-19 should be visible.
-            AssertRealizedItems(target, itemsControl, 10, 10);
+            AssertRealizedItems(target, itemsControl, firstIndex, count);
         }
 
-        [Fact]
-        public void ScrollIntoView_Correctly_Scrolls_Down_To_A_Page_Of_Larger_Items()
+        [Theory]
+        [InlineData(0d, 15, 5, 190, 210, 110)]
+        [InlineData(0.5d, 10, 10, 253, 273, 173)]
+        public void ScrollIntoView_Correctly_Scrolls_Down_To_A_Page_Of_Larger_Items(double bufferFactor, int firstIndex, int count, int y, int extentHeight, int offset)
         {
             using var app = App();
 
             // First 10 items have height of 10, next 10 have height of 20.
             var items = Enumerable.Range(0, 20).Select(x => new ItemWithHeight(x, ((x / 10) + 1) * 10));
-            var (target, scroll, itemsControl) = CreateTarget(items: items, itemTemplate: CanvasWithHeightTemplate);
+            var (target, scroll, itemsControl) = CreateTarget(items: items, itemTemplate: CanvasWithHeightTemplate, bufferFactor: bufferFactor);
 
             // Scroll the last item into view.
             target.ScrollIntoView(19);
@@ -1252,23 +1398,28 @@ namespace Avalonia.Controls.UnitTests
             // accommodate the item height of 20. This is obviously not a perfect answer, but
             // it's the best we can do without knowing the actual item heights.
             var container = Assert.IsType<ContentPresenter>(target.ContainerFromIndex(19));
-            Assert.Equal(new Rect(0, 190, 100, 20), container.Bounds);
+            Assert.Equal(new Rect(0, y, 100, 20), container.Bounds);
             Assert.Equal(new Size(100, 100), scroll.Viewport);
-            Assert.Equal(new Size(100, 210), scroll.Extent);
-            Assert.Equal(new Vector(0, 110), scroll.Offset);
+            Assert.Equal(new Size(100, extentHeight), scroll.Extent);
+            Assert.Equal(new Vector(0, offset), scroll.Offset);
 
             // Items 15-19 should be visible.
-            AssertRealizedItems(target, itemsControl, 15, 5);
+            AssertRealizedItems(target, itemsControl, firstIndex, count);
         }
 
-        [Fact]
-        public void ScrollIntoView_Correctly_Scrolls_Right_To_A_Page_Of_Smaller_Items()
+        [Theory]
+        [InlineData(0d, 10,10)]
+        [InlineData(0.5d, 5, 15)]
+        public void ScrollIntoView_Correctly_Scrolls_Right_To_A_Page_Of_Smaller_Items(double bufferFactor, int firstIndex, int count)
         {
             using var app = App();
 
             // First 10 items have width of 20, next 10 have width of 10.
             var items = Enumerable.Range(0, 20).Select(x => new ItemWithWidth(x, ((29 - x) / 10) * 10));
-            var (target, scroll, itemsControl) = CreateTarget(items: items, itemTemplate: CanvasWithWidthTemplate, orientation: Orientation.Horizontal);
+            var (target, scroll, itemsControl) = CreateTarget(items: items,
+                itemTemplate: CanvasWithWidthTemplate, 
+                orientation: Orientation.Horizontal,
+                bufferFactor: bufferFactor);
 
             // Scroll the last item into view.
             target.ScrollIntoView(19);
@@ -1284,17 +1435,22 @@ namespace Avalonia.Controls.UnitTests
             Assert.Equal(new Vector(290, 0), scroll.Offset);
 
             // Items 10-19 should be visible.
-            AssertRealizedItems(target, itemsControl, 10, 10);
+            AssertRealizedItems(target, itemsControl, firstIndex, count);
         }
 
-        [Fact]
-        public void ScrollIntoView_Correctly_Scrolls_Right_To_A_Page_Of_Larger_Items()
+        [Theory]
+        [InlineData(0d, 15, 5, 190, 210, 110)]
+        [InlineData(0.5d, 10, 10, 253, 273, 173)]
+        public void ScrollIntoView_Correctly_Scrolls_Right_To_A_Page_Of_Larger_Items(double bufferFactor, int firstIndex, int count, int x, int extentWidth, int offset)
         {
             using var app = App();
 
             // First 10 items have width of 10, next 10 have width of 20.
             var items = Enumerable.Range(0, 20).Select(x => new ItemWithWidth(x, ((x / 10) + 1) * 10));
-            var (target, scroll, itemsControl) = CreateTarget(items: items, itemTemplate: CanvasWithWidthTemplate, orientation: Orientation.Horizontal);
+            var (target, scroll, itemsControl) = CreateTarget(items: items,
+                itemTemplate: CanvasWithWidthTemplate, 
+                orientation: Orientation.Horizontal,
+                bufferFactor: bufferFactor);
 
             // Scroll the last item into view.
             target.ScrollIntoView(19);
@@ -1304,28 +1460,36 @@ namespace Avalonia.Controls.UnitTests
             // accommodate the item width of 20. This is obviously not a perfect answer, but
             // it's the best we can do without knowing the actual item widths.
             var container = Assert.IsType<ContentPresenter>(target.ContainerFromIndex(19));
-            Assert.Equal(new Rect(190, 0, 20, 100), container.Bounds);
+            Assert.Equal(new Rect(x, 0, 20, 100), container.Bounds);
             Assert.Equal(new Size(100, 100), scroll.Viewport);
-            Assert.Equal(new Size(210, 100), scroll.Extent);
-            Assert.Equal(new Vector(110, 0), scroll.Offset);
+            Assert.Equal(new Size(extentWidth, 100), scroll.Extent);
+            Assert.Equal(new Vector(offset, 0), scroll.Offset);
 
             // Items 15-19 should be visible.
-            AssertRealizedItems(target, itemsControl, 15, 5);
+            AssertRealizedItems(target, itemsControl, firstIndex, count);
         }
 
-        [Fact]
-        public void Extent_And_Offset_Should_Be_Updated_When_Containers_Resize()
+        [Theory]
+        [InlineData(0d, 
+            4,5,
+            8, 11)]
+        [InlineData(0.5d, 
+            3,6,
+            6, 13)]
+        public void Extent_And_Offset_Should_Be_Updated_When_Containers_Resize(double bufferFactor, 
+            int firstIndex1, int lastIndex1, 
+            int firstIndex2, int lastIndex2)
         {
             using var app = App();
 
             // All containers start off with a height of 50 (2 containers fit in viewport).
             var items = Enumerable.Range(0, 20).Select(x => new ItemWithHeight(x, 50)).ToList();
-            var (target, scroll, itemsControl) = CreateTarget(items: items, itemTemplate: CanvasWithHeightTemplate);
+            var (target, scroll, itemsControl) = CreateTarget(items: items, itemTemplate: CanvasWithHeightTemplate, bufferFactor: bufferFactor);
 
             // Scroll to the 5th item (containers 4 and 5 should be visible).
             target.ScrollIntoView(5);
-            Assert.Equal(4, target.FirstRealizedIndex);
-            Assert.Equal(5, target.LastRealizedIndex);
+            Assert.Equal(firstIndex1, target.FirstRealizedIndex);
+            Assert.Equal(lastIndex1, target.LastRealizedIndex);
 
             // The extent should be 500 (10 * 50) and the offset should be 200 (4 * 50).
             var container = Assert.IsType<ContentPresenter>(target.ContainerFromIndex(5));
@@ -1344,23 +1508,31 @@ namespace Avalonia.Controls.UnitTests
             Assert.Equal(new Size(100, 100), scroll.Viewport);
             Assert.Equal(new Size(100, 500), scroll.Extent);
             Assert.Equal(new Vector(0, 200), scroll.Offset);
-            Assert.Equal(8, target.FirstRealizedIndex);
-            Assert.Equal(11, target.LastRealizedIndex);
+            Assert.Equal(firstIndex2, target.FirstRealizedIndex);
+            Assert.Equal(lastIndex2, target.LastRealizedIndex);
         }
 
-        [Fact]
-        public void Focused_Container_Is_Positioned_Correctly_when_Container_Size_Change_Causes_It_To_Be_Moved_Out_Of_Visible_Viewport()
+        [Theory]
+        [InlineData(0d,
+            4, 5,
+            8, 11)]
+        [InlineData(0.5d,
+            3, 6,
+            6, 13)]
+        public void Focused_Container_Is_Positioned_Correctly_when_Container_Size_Change_Causes_It_To_Be_Moved_Out_Of_Visible_Viewport(double bufferFactor,
+            int firstIndex1, int lastIndex1,
+            int firstIndex2, int lastIndex2)
         {
             using var app = App();
 
             // All containers start off with a height of 50 (2 containers fit in viewport).
             var items = Enumerable.Range(0, 20).Select(x => new ItemWithHeight(x, 50)).ToList();
-            var (target, scroll, itemsControl) = CreateTarget(items: items, itemTemplate: CanvasWithHeightTemplate);
+            var (target, scroll, itemsControl) = CreateTarget(items: items, itemTemplate: CanvasWithHeightTemplate, bufferFactor: bufferFactor);
 
             // Scroll to the 5th item (containers 4 and 5 should be visible).
             target.ScrollIntoView(5);
-            Assert.Equal(4, target.FirstRealizedIndex);
-            Assert.Equal(5, target.LastRealizedIndex);
+            Assert.Equal(firstIndex1, target.FirstRealizedIndex);
+            Assert.Equal(lastIndex1, target.LastRealizedIndex);
 
             // Focus the 5th item.
             var container = Assert.IsType<ContentPresenter>(target.ContainerFromIndex(5));
@@ -1373,27 +1545,38 @@ namespace Avalonia.Controls.UnitTests
             target.UpdateLayout();
 
             // The focused container should now be outside the realized range.
-            Assert.Equal(8, target.FirstRealizedIndex);
-            Assert.Equal(11, target.LastRealizedIndex);
+            Assert.Equal(firstIndex2, target.FirstRealizedIndex);
+            Assert.Equal(lastIndex2, target.LastRealizedIndex);
 
             // The container should still exist and be positioned outside the visible viewport.
             container = Assert.IsType<ContentPresenter>(target.ContainerFromIndex(5));
             Assert.Equal(new Rect(0, 125, 100, 25), container.Bounds);
         }
 
-        [Fact]
-        public void Focused_Container_Is_Positioned_Correctly_when_Container_Size_Change_Causes_It_To_Be_Moved_Into_Visible_Viewport()
+        [Theory]
+        [InlineData(0d, 
+            4, 7,
+            3, 6, 
+            3, 7)]
+        [InlineData(0.5d,
+            0, 7,
+            0, 7,
+            0, 9)]
+        public void Focused_Container_Is_Positioned_Correctly_when_Container_Size_Change_Causes_It_To_Be_Moved_Into_Visible_Viewport(double bufferFactor, 
+            int firstIndex1, int lastIndex1,
+            int firstIndex2, int lastIndex2,
+            int firstIndex3, int lastIndex3)
         {
             using var app = App();
 
             // All containers start off with a height of 25 (4 containers fit in viewport).
             var items = Enumerable.Range(0, 20).Select(x => new ItemWithHeight(x, 25)).ToList();
-            var (target, scroll, itemsControl) = CreateTarget(items: items, itemTemplate: CanvasWithHeightTemplate);
+            var (target, scroll, itemsControl) = CreateTarget(items: items, itemTemplate: CanvasWithHeightTemplate, bufferFactor: bufferFactor);
 
             // Scroll to the 5th item (containers 4-7 should be visible).
             target.ScrollIntoView(7);
-            Assert.Equal(4, target.FirstRealizedIndex);
-            Assert.Equal(7, target.LastRealizedIndex);
+            Assert.Equal(firstIndex1, target.FirstRealizedIndex);
+            Assert.Equal(lastIndex1, target.LastRealizedIndex);
 
             // Focus the 7th item.
             var container = Assert.IsType<ContentPresenter>(target.ContainerFromIndex(7));
@@ -1402,8 +1585,8 @@ namespace Avalonia.Controls.UnitTests
 
             // Scroll up to the 3rd item (containers 3-6 should still be visible).
             target.ScrollIntoView(3);
-            Assert.Equal(3, target.FirstRealizedIndex);
-            Assert.Equal(6, target.LastRealizedIndex);
+            Assert.Equal(firstIndex2, target.FirstRealizedIndex);
+            Assert.Equal(lastIndex2, target.LastRealizedIndex);
 
             // Update the height of all items to 20 and run a layout pass.
             foreach (var item in items)
@@ -1411,14 +1594,598 @@ namespace Avalonia.Controls.UnitTests
             target.UpdateLayout();
 
             // The focused container should now be inside the realized range.
-            Assert.Equal(3, target.FirstRealizedIndex);
-            Assert.Equal(7, target.LastRealizedIndex);
+            Assert.Equal(firstIndex3, target.FirstRealizedIndex);
+            Assert.Equal(lastIndex3, target.LastRealizedIndex);
 
             // The container should be positioned correctly.
             container = Assert.IsType<ContentPresenter>(target.ContainerFromIndex(7));
             Assert.Equal(new Rect(0, 140, 100, 20), container.Bounds);
         }
 
+        [Fact]
+        public void When_Vertical_Calculates_ViewPort_At_Start_Of_List()
+        {
+            // Arrange
+            using var app = App();
+
+            var items = Enumerable.Range(0, 100).Select(x => new ItemWithHeight(x)).ToList();
+
+            // Act
+            var (target, scroll, itemsControl) = 
+                CreateTarget<ItemsControl, VirtualizingStackPanelCountingMeasureArrange>(
+                    items: items, 
+                    itemTemplate: CanvasWithHeightTemplate,
+                    bufferFactor:0.5d);
+
+            // Assert
+            Assert.Equal(0, target.ViewPort.Top);
+            Assert.Equal(100, target.ViewPort.Bottom);
+
+            Assert.Equal(0, target.ExtendedViewPort.Top);
+            Assert.Equal(200, target.ExtendedViewPort.Bottom);
+        }
+
+        [Fact]
+        public void When_Vertical_Calculates_ViewPort_At_End_Of_List()
+        {
+            // Arrange
+            using var app = App();
+
+            var items = Enumerable.Range(0, 100).Select(x => new ItemWithHeight(x)).ToList();
+            var (target, scroll, itemsControl) = 
+                CreateTarget<ItemsControl, VirtualizingStackPanelCountingMeasureArrange>(
+                    items: items, 
+                    itemTemplate: CanvasWithHeightTemplate,
+                    bufferFactor: 0.5d);
+
+            // Act
+            scroll.Offset = new Vector(0, 910); // scroll to end
+            Layout(target);
+
+            // Assert
+            Assert.Equal(900, target.ViewPort.Top);
+            Assert.Equal(1000, target.ViewPort.Bottom);
+
+            Assert.Equal(800, target.ExtendedViewPort.Top);
+            Assert.Equal(1000, target.ExtendedViewPort.Bottom);
+        }
+
+        [Fact]
+        public void When_Vertical_Calculates_ViewPort_In_Middle_Of_List()
+        {
+            // Arrange
+            using var app = App();
+
+            var items = Enumerable.Range(0, 100).Select(x => new ItemWithHeight(x)).ToList();
+            var (target, scroll, itemsControl) = 
+                CreateTarget<ItemsControl, VirtualizingStackPanelCountingMeasureArrange>(
+                    items: items,
+                    itemTemplate: CanvasWithHeightTemplate,
+                    bufferFactor: 0.5d);
+
+            // Act
+            scroll.Offset = new Vector(0, 500); // scroll to end
+            Layout(target);
+
+            // Assert
+            Assert.Equal(500, target.ViewPort.Top);
+            Assert.Equal(600, target.ViewPort.Bottom);
+
+            Assert.Equal(450, target.ExtendedViewPort.Top);
+            Assert.Equal(650, target.ExtendedViewPort.Bottom);
+        }
+
+        [Fact]
+        public void When_Horizontal_Calculates_ViewPort_At_Start_Of_List()
+        {
+            // Arrange
+            using var app = App();
+
+            var items = Enumerable.Range(0, 100).Select(x => new ItemWithWidth(x)).ToList();
+
+            // Act
+            var (target, scroll, itemsControl) = 
+                CreateTarget<ItemsControl, VirtualizingStackPanelCountingMeasureArrange>(
+                    items: items, 
+                    itemTemplate: CanvasWithWidthTemplate, 
+                    orientation: Orientation.Horizontal,
+                    bufferFactor: 0.5d);
+
+            // Assert
+            Assert.Equal(0, target.ViewPort.Left);
+            Assert.Equal(100, target.ViewPort.Right);
+
+            Assert.Equal(0, target.ExtendedViewPort.Left);
+            Assert.Equal(200, target.ExtendedViewPort.Right);
+        }
+
+        [Fact]
+        public void When_Horizontal_Calculates_ViewPort_At_End_Of_List()
+        {
+            // Arrange
+            using var app = App();
+
+            var items = Enumerable.Range(0, 100).Select(x => new ItemWithWidth(x)).ToList();
+            var (target, scroll, itemsControl) = 
+                CreateTarget<ItemsControl, VirtualizingStackPanelCountingMeasureArrange>(
+                    items: items, 
+                    itemTemplate: CanvasWithWidthTemplate, 
+                    orientation: Orientation.Horizontal,
+                    bufferFactor: 0.5d);
+            // Act
+            scroll.Offset = new Vector(900, 0); // scroll to end
+            Layout(target);
+
+            // Assert
+            Assert.Equal(900, target.ViewPort.Left);
+            Assert.Equal(1000, target.ViewPort.Right);
+
+            Assert.Equal(800, target.ExtendedViewPort.Left);
+            Assert.Equal(1000, target.ExtendedViewPort.Right);
+        }
+
+        [Fact]
+        public void When_Horizontal_Calculates_ViewPort_In_Middle_Of_List()
+        {
+            // Arrange
+            using var app = App();
+
+            var items = Enumerable.Range(0, 100).Select(x => new ItemWithWidth(x)).ToList();
+            var (target, scroll, itemsControl) =
+                CreateTarget<ItemsControl, VirtualizingStackPanelCountingMeasureArrange>(
+                    items: items, 
+                    itemTemplate: CanvasWithWidthTemplate, 
+                    orientation: Orientation.Horizontal,
+                    bufferFactor: 0.5d);
+
+            // Act
+            scroll.Offset = new Vector(500, 0); // scroll to end
+            Layout(target);
+
+            // Assert
+            Assert.Equal(500, target.ViewPort.Left);
+            Assert.Equal(600, target.ViewPort.Right);
+
+            Assert.Equal(450, target.ExtendedViewPort.Left);
+            Assert.Equal(650, target.ExtendedViewPort.Right);
+        }
+
+        [Fact]
+        public void Scrolling_Down_Does_Not_Measure_Or_Arrange_Until_Extended_ViewPort_Bounds_Are_Reached()
+        {
+            using var app = App();
+
+            var items = Enumerable.Range(0, 100).Select(x => new ItemWithHeightAndMeasureArrangeCount(x)).ToList();
+
+            var (target, scroll, itemsControl) = 
+                CreateTarget<ItemsControl, VirtualizingStackPanelCountingMeasureArrange>(
+                    items: items, 
+                    itemTemplate: CanvasWithHeightTemplate,
+                    bufferFactor: 0.5d);
+
+            Assert.True(target.LastRealizedIndex == 19,
+                $"Should show 20 items but last realized index was {target.LastRealizedIndex}");
+
+            // reset counters
+            target.ResetMeasureArrangeCounters();
+            // shows 20 items, each is 10 high.
+            // visible are 10 => need to scroll down 100px until the next 5 (visible*BufferFactor) additional items are added.
+            // until then no measure-arrange call should happen
+
+            // Scroll down until the extended viewport bounds are reached
+            while (target.LastRealizedIndex < 20)
+            {
+                scroll.Offset = new Vector(0, scroll.Offset.Y + 5);
+                Layout(target);
+            }
+
+            // Assert
+            Assert.True(target.Measured == 1, "should be measured only once");
+            Assert.True(target.Arranged == 1, "should be arranged only once");
+
+            // the first 5 additional items will be reused when scrolling down, but the remaining 10 visible + 5 additional not touched at all
+            var expectedUntouchedItems =
+                items.Skip(5 /*additional items*/).Take(15).ToList();
+            foreach (var itm in expectedUntouchedItems)
+            {
+                Assert.True(itm.Measured == 0, $"{itm.Caption} should not be measured but was {itm.Measured} times");
+                Assert.True(itm.Arranged == 0, $"{itm.Caption} should not be arranged but was {itm.Arranged} times");
+            }
+
+            var newAdditionalItems = items.Skip(20).Take(5);
+            foreach (var itm in newAdditionalItems)
+            {
+                Assert.True(itm.Measured == 1, $"{itm.Caption} should be measured but was {itm.Measured} times");
+                Assert.True(itm.Arranged == 1, $"{itm.Caption} should be measured but was {itm.Arranged} times");
+            }
+        }
+
+        [Fact]
+        public void Scrolling_Up_Does_Not_Measure_Or_Arrange_Until_Extended_ViewPort_Bounds_Are_Reached()
+        {
+            using var app = App();
+
+            var items = Enumerable.Range(0, 100).Select(x => new ItemWithHeightAndMeasureArrangeCount(x)).ToList();
+
+            var (target, scroll, itemsControl) = 
+                CreateTarget<ItemsControl, VirtualizingStackPanelCountingMeasureArrange>(
+                    items: items, 
+                    itemTemplate: CanvasWithHeightTemplate,
+                    bufferFactor: 0.5d);
+
+            // scroll a bit down so we are not near the start of the list
+            scroll.Offset = new Vector(0, 200);
+            Layout(target);
+
+            Assert.True(target.FirstRealizedIndex == 15,
+                $"Should show items from 20 to 30 (so 15 to 35 including additional items) but first realized index was {target.FirstRealizedIndex}");
+
+            // reset counters
+            target.ResetMeasureArrangeCounters();
+            // shows 20 items, each is 10 high.
+            // visible are 10 => need to scroll down 100px until the next 5 (visible*BufferFactor) additional items are added.
+            // until then no measure-arrange call should happen
+
+            var initialFirstRealizedIndex = target.FirstRealizedIndex;
+
+            // Scroll down until the extended viewport bounds are reached
+            while (target.FirstRealizedIndex >= 15)
+            {
+                scroll.Offset = new Vector(0, scroll.Offset.Y - 5);
+                Layout(target);
+            }
+
+            // Assert
+            Assert.True(target.Measured == 1, "should be measured only once");
+            Assert.True(target.Arranged == 1, "should be arranged only once");
+
+            // the last 5 additional items will be reused when scrolling up, but the remaining 10 visible + 5 additional not touched at all
+            var expectedUntouchedItems = items.Skip(initialFirstRealizedIndex + 1).Take(15).ToList();
+            foreach (var itm in expectedUntouchedItems)
+            {
+                Assert.True(itm.Measured == 0, $"{itm.Caption} should not be measured but was {itm.Measured} times");
+                Assert.True(itm.Arranged == 0, $"{itm.Caption} should not be arranged but was {itm.Arranged} times");
+            }
+
+            // now that we scrolled up to index 19, items 18,17,16,15 and 14 should be the "additional" ones
+            var newAdditionalItems = items.Skip(initialFirstRealizedIndex - 6).Take(6);
+            foreach (var itm in newAdditionalItems)
+            {
+                Assert.True(itm.Measured == 1, $"{itm.Caption} should be measured but was {itm.Measured} times");
+                Assert.True(itm.Arranged == 1, $"{itm.Caption} should be measured but was {itm.Arranged} times");
+            }
+        }
+
+        [Fact]
+        public void Scrolling_Down_To_End_Of_List_Only_Measures_Once_When_Last_Item_Is_Reached()
+        {
+            using var app = App();
+
+            var items = Enumerable.Range(0, 100).Select(x => new ItemWithHeightAndMeasureArrangeCount(x)).ToList();
+
+            var (target, scroll, itemsControl) = 
+                CreateTarget<ItemsControl, VirtualizingStackPanelCountingMeasureArrange>(
+                    items: items, 
+                    itemTemplate: CanvasWithHeightTemplate,
+                    bufferFactor: 0.5d);
+
+            // scroll a bit down so we are near the end of the list
+            scroll.Offset = new Vector(0, 800); // so we render 75 to 95 with a buffer size of 5
+            Layout(target);
+
+            Assert.True(target.LastRealizedIndex == 94,
+                $"Should show 20 items but last realized index was {target.LastRealizedIndex}");
+
+            // reset counters
+            target.ResetMeasureArrangeCounters();
+            // shows 20 items, each is 10 high.
+            // visible are 10 => need to scroll down 100px until the next 5 (visible*BufferFactor) additional items are added.
+            // until then no measure-arrange call should happen
+
+            var initialLastRealizedIndex = target.LastRealizedIndex;
+
+            // Scroll down until we reached the very last item
+            while (target.LastRealizedIndex < 99)
+            {
+                scroll.Offset = new Vector(0, scroll.Offset.Y + 5);
+                Layout(target);
+            }
+
+            // Assert
+            Assert.True(target.Measured == 1, "should be measured only once even though we are at the end of the list");
+            Assert.True(target.Arranged == 1, "should be arranged only once even though we are at the end of the list");
+
+            // the first 5 additional items will be reused when scrolling down, but the remaining 10 visible + 5 additional not touched at all
+            var expectedUntouchedItems =
+                items.Skip(initialLastRealizedIndex + 1 - 15).Take(15).ToList();
+            foreach (var itm in expectedUntouchedItems)
+            {
+                Assert.True(itm.Measured == 0, $"{itm.Caption} should not be measured but was {itm.Measured} times");
+                Assert.True(itm.Arranged == 0, $"{itm.Caption} should not be arranged but was {itm.Arranged} times");
+            }
+
+            var newAdditionalItems = items.Skip(initialLastRealizedIndex + 1).Take(5);
+            foreach (var itm in newAdditionalItems)
+            {
+                Assert.True(itm.Measured == 1, $"{itm.Caption} should be measured but was {itm.Measured} times");
+                Assert.True(itm.Arranged == 1, $"{itm.Caption} should be measured but was {itm.Arranged} times");
+            }
+        }
+
+        [Fact]
+        public void Scrolling_Up_To_Start_Of_List_Only_Measures_Once_When_First_Item_Is_Reached()
+        {
+            using var app = App();
+
+            var items = Enumerable.Range(0, 100).Select(x => new ItemWithHeightAndMeasureArrangeCount(x)).ToList();
+
+            var (target, scroll, itemsControl) = 
+                CreateTarget<ItemsControl, VirtualizingStackPanelCountingMeasureArrange>(
+                    items: items, 
+                    itemTemplate: CanvasWithHeightTemplate,
+                    bufferFactor: 0.5d);
+
+            // scroll a bit down so we are not near the start of the list
+            scroll.Offset = new Vector(0, 105);
+            Layout(target);
+
+            Assert.True(target.FirstRealizedIndex == 5,
+                $"Should show items from 10 to 20 (so 5 to 25 including additional items) but first realized index was {target.FirstRealizedIndex}");
+
+            // reset counters
+            target.ResetMeasureArrangeCounters();
+            // shows 20 items, each is 10 high.
+            // visible are 10 => need to scroll down 100px until the next 5 (visible*BufferFactor) additional items are added.
+            // until then no measure-arrange call should happen
+
+            // Scroll down until the extended viewport bounds are reached
+            while (target.FirstRealizedIndex > 0)
+            {
+                scroll.Offset = new Vector(0, scroll.Offset.Y - 5);
+                Layout(target);
+            }
+
+            // Assert
+            Assert.True(target.Measured == 1, "should be measured only once even though we are at the start of the list");
+            Assert.True(target.Arranged == 1, "should be arranged only once even though we are at the start of the list");
+
+            // the last 5 additional items will be reused when scrolling up, but the remaining 10 visible + 5 additional not touched at all
+            var expectedMeasuredItems = items.Take(20).ToList();
+            foreach (var itm in expectedMeasuredItems)
+            {
+                Assert.True(itm.Measured == 1, $"{itm.Caption} should be measured but was {itm.Measured} times");
+                Assert.True(itm.Arranged == 1, $"{itm.Caption} should be arranged but was {itm.Arranged} times");
+            }
+
+            // now that we scrolled up to index 19, items 18,17,16,15 and 14 should be the "additional" ones
+            var untouchedItems = items.Skip(20).ToList();
+            foreach (var itm in untouchedItems)
+            {
+                Assert.True(itm.Measured == 0, $"{itm.Caption} should not be measured but was {itm.Measured} times");
+                Assert.True(itm.Arranged == 0, $"{itm.Caption} should not be measured but was {itm.Arranged} times");
+            }
+        }
+
+        [Fact]
+        public void Scrolling_Right_Does_Not_Measure_Or_Arrange_Until_Extended_ViewPort_Bounds_Are_Reached()
+        {
+            using var app = App();
+
+            var items = Enumerable.Range(0, 100).Select(x => new ItemWithWidthAndMeasureArrangeCount(x)).ToList();
+
+            var (target, scroll, itemsControl) = 
+                CreateTarget<ItemsControl, VirtualizingStackPanelCountingMeasureArrange>(
+                    items: items,
+                    itemTemplate: CanvasWithWidthTemplate, 
+                    orientation: Orientation.Horizontal,
+                    bufferFactor: 0.5d);
+
+            Assert.True(target.LastRealizedIndex == 19,
+                $"Should show 20 items but last realized index was {target.LastRealizedIndex}");
+
+            // reset counters
+            target.ResetMeasureArrangeCounters();
+            // shows 20 items, each is 10 high.
+            // visible are 10 => need to scroll down 100px until the next 5 (visible*BufferFactor) additional items are added.
+            // until then no measure-arrange call should happen
+
+            // Scroll down until the extended viewport bounds are reached
+            while (target.LastRealizedIndex < 20)
+            {
+                scroll.Offset = new Vector(scroll.Offset.X + 5, 0);
+                Layout(target);
+            }
+
+            // Assert
+            Assert.True(target.Measured == 1, "should be measured only once");
+            Assert.True(target.Arranged == 1, "should be arranged only once");
+
+            // the first 5 additional items will be reused when scrolling down, but the remaining 10 visible + 5 additional not touched at all
+            var expectedUntouchedItems =
+                items.Skip(5 /*additional items*/).Take(15).ToList();
+            foreach (var itm in expectedUntouchedItems)
+            {
+                Assert.True(itm.Measured == 0, $"{itm.Caption} should not be measured but was {itm.Measured} times");
+                Assert.True(itm.Arranged == 0, $"{itm.Caption} should not be arranged but was {itm.Arranged} times");
+            }
+
+            var newAdditionalItems = items.Skip(20).Take(5);
+            foreach (var itm in newAdditionalItems)
+            {
+                Assert.True(itm.Measured == 1, $"{itm.Caption} should be measured but was {itm.Measured} times");
+                Assert.True(itm.Arranged == 1, $"{itm.Caption} should be measured but was {itm.Arranged} times");
+            }
+        }
+
+        [Fact]
+        public void Scrolling_Left_Does_Not_Measure_Or_Arrange_Until_Extended_ViewPort_Bounds_Are_Reached()
+        {
+            using var app = App();
+
+            var items = Enumerable.Range(0, 100).Select(x => new ItemWithWidthAndMeasureArrangeCount(x)).ToList();
+
+            var (target, scroll, itemsControl) = 
+                CreateTarget<ItemsControl, VirtualizingStackPanelCountingMeasureArrange>(
+                    items: items,
+                    itemTemplate: CanvasWithWidthTemplate, 
+                    orientation: Orientation.Horizontal,
+                    bufferFactor: 0.5d);
+
+            // scroll a bit down so we are not near the start of the list
+            scroll.Offset = new Vector(200, 0);
+            Layout(target);
+
+            Assert.True(target.FirstRealizedIndex == 15,
+                $"Should show items from 20 to 30 (so 15 to 35 including additional items) but first realized index was {target.FirstRealizedIndex}");
+
+            // reset counters
+            target.ResetMeasureArrangeCounters();
+            // shows 20 items, each is 10 high.
+            // visible are 10 => need to scroll down 100px until the next 5 (visible*BufferFactor) additional items are added.
+            // until then no measure-arrange call should happen
+
+            var initialFirstRealizedIndex = target.FirstRealizedIndex;
+
+            // Scroll down until the extended viewport bounds are reached
+            while (target.FirstRealizedIndex >= 15)
+            {
+                scroll.Offset = new Vector(scroll.Offset.X - 5, 0);
+                Layout(target);
+            }
+
+            // Assert
+            Assert.True(target.Measured == 1, "should be measured only once");
+            Assert.True(target.Arranged == 1, "should be arranged only once");
+
+            // the last 5 additional items will be reused when scrolling up, but the remaining 10 visible + 5 additional not touched at all
+            var expectedUntouchedItems = items.Skip(initialFirstRealizedIndex + 1).Take(15).ToList();
+            foreach (var itm in expectedUntouchedItems)
+            {
+                Assert.True(itm.Measured == 0, $"{itm.Caption} should not be measured but was {itm.Measured} times");
+                Assert.True(itm.Arranged == 0, $"{itm.Caption} should not be arranged but was {itm.Arranged} times");
+            }
+
+            // now that we scrolled up to index 19, items 18,17,16,15 and 14 should be the "additional" ones
+            var newAdditionalItems = items.Skip(initialFirstRealizedIndex - 6).Take(6);
+            foreach (var itm in newAdditionalItems)
+            {
+                Assert.True(itm.Measured == 1, $"{itm.Caption} should be measured but was {itm.Measured} times");
+                Assert.True(itm.Arranged == 1, $"{itm.Caption} should be measured but was {itm.Arranged} times");
+            }
+        }
+
+        [Fact]
+        public void Scrolling_Right_To_End_Of_List_Only_Measures_Once_When_Last_Item_Is_Reached()
+        {
+            using var app = App();
+
+            var items = Enumerable.Range(0, 100).Select(x => new ItemWithWidthAndMeasureArrangeCount(x)).ToList();
+
+            var (target, scroll, itemsControl) = 
+                CreateTarget<ItemsControl, VirtualizingStackPanelCountingMeasureArrange>(
+                    items: items,
+                    itemTemplate: CanvasWithWidthTemplate,
+                    orientation: Orientation.Horizontal,
+                    bufferFactor: 0.5d);
+
+            // scroll a bit down so we are near the end of the list
+            scroll.Offset = new Vector(800, 0); // so we render 75 to 95 with a buffer size of 5
+            Layout(target);
+
+            Assert.True(target.LastRealizedIndex == 94,
+                $"Should show 20 items but last realized index was {target.LastRealizedIndex}");
+
+            // reset counters
+            target.ResetMeasureArrangeCounters();
+            // shows 20 items, each is 10 high.
+            // visible are 10 => need to scroll down 100px until the next 5 (visible*BufferFactor) additional items are added.
+            // until then no measure-arrange call should happen
+
+            var initialLastRealizedIndex = target.LastRealizedIndex;
+
+            // Scroll down until we reached the very last item
+            while (target.LastRealizedIndex < 99)
+            {
+                scroll.Offset = new Vector(scroll.Offset.X + 5, 0);
+                Layout(target);
+            }
+
+            // Assert
+            Assert.True(target.Measured == 1, "should be measured only once even though we are at the end of the list");
+            Assert.True(target.Arranged == 1, "should be arranged only once even though we are at the end of the list");
+
+            // the first 5 additional items will be reused when scrolling down, but the remaining 10 visible + 5 additional not touched at all
+            var expectedUntouchedItems =
+                items.Skip(initialLastRealizedIndex + 1 - 15).Take(15).ToList();
+            foreach (var itm in expectedUntouchedItems)
+            {
+                Assert.True(itm.Measured == 0, $"{itm.Caption} should not be measured but was {itm.Measured} times");
+                Assert.True(itm.Arranged == 0, $"{itm.Caption} should not be arranged but was {itm.Arranged} times");
+            }
+
+            var newAdditionalItems = items.Skip(initialLastRealizedIndex + 1).Take(5);
+            foreach (var itm in newAdditionalItems)
+            {
+                Assert.True(itm.Measured == 1, $"{itm.Caption} should be measured but was {itm.Measured} times");
+                Assert.True(itm.Arranged == 1, $"{itm.Caption} should be measured but was {itm.Arranged} times");
+            }
+        }
+
+        [Fact]
+        public void Scrolling_Left_To_Start_Of_List_Only_Measures_Once_When_First_Item_Is_Reached()
+        {
+            using var app = App();
+
+            var items = Enumerable.Range(0, 100).Select(x => new ItemWithWidthAndMeasureArrangeCount(x)).ToList();
+
+            var (target, scroll, itemsControl) = 
+                CreateTarget<ItemsControl, VirtualizingStackPanelCountingMeasureArrange>(
+                    items: items,
+                    itemTemplate: CanvasWithWidthTemplate, 
+                    orientation: Orientation.Horizontal,
+                    bufferFactor: 0.5d);
+
+            // scroll a bit down so we are not near the start of the list
+            scroll.Offset = new Vector(105, 0);
+            Layout(target);
+
+            Assert.True(target.FirstRealizedIndex == 5,
+                $"Should show items from 10 to 20 (so 5 to 25 including additional items) but first realized index was {target.FirstRealizedIndex}");
+
+            // reset counters
+            target.ResetMeasureArrangeCounters();
+            // shows 20 items, each is 10 high.
+            // visible are 10 => need to scroll down 100px until the next 5 (visible*BufferFactor) additional items are added.
+            // until then no measure-arrange call should happen
+
+            // Scroll down until the extended viewport bounds are reached
+            while (target.FirstRealizedIndex > 0)
+            {
+                scroll.Offset = new Vector(scroll.Offset.X - 5, 0);
+                Layout(target);
+            }
+
+            // Assert
+            Assert.True(target.Measured == 1, "should be measured only once even though we are at the start of the list");
+            Assert.True(target.Arranged == 1, "should be arranged only once even though we are at the start of the list");
+
+            // the last 5 additional items will be reused when scrolling up, but the remaining 10 visible + 5 additional not touched at all
+            var expectedMeasuredItems = items.Take(20).ToList();
+            foreach (var itm in expectedMeasuredItems)
+            {
+                Assert.True(itm.Measured == 1, $"{itm.Caption} should be measured but was {itm.Measured} times");
+                Assert.True(itm.Arranged == 1, $"{itm.Caption} should be arranged but was {itm.Arranged} times");
+            }
+
+            // now that we scrolled up to index 19, items 18,17,16,15 and 14 should be the "additional" ones
+            var untouchedItems = items.Skip(20).ToList();
+            foreach (var itm in untouchedItems)
+            {
+                Assert.True(itm.Measured == 0, $"{itm.Caption} should not be measured but was {itm.Measured} times");
+                Assert.True(itm.Arranged == 0, $"{itm.Caption} should not be measured but was {itm.Arranged} times");
+            }
+        }
+
         private static IReadOnlyList<int> GetRealizedIndexes(VirtualizingStackPanel target, ItemsControl itemsControl)
         {
             return target.GetRealizedElements()
@@ -1465,28 +2232,33 @@ namespace Avalonia.Controls.UnitTests
                 .ToList();
             Assert.Equal(Enumerable.Range(firstIndex, count), childIndexes);
         }
-
         private static (VirtualizingStackPanel, ScrollViewer, ItemsControl) CreateTarget(
             IEnumerable<object>? items = null,
             Optional<IDataTemplate?> itemTemplate = default,
             IEnumerable<Style>? styles = null,
-            Orientation orientation = Orientation.Vertical)
+            Orientation orientation = Orientation.Vertical,
+            double bufferFactor = 0.0d)
         {
-            return CreateTarget<ItemsControl>(
+            return CreateTarget<ItemsControl, VirtualizingStackPanel>(
                 items: items,
                 itemTemplate: itemTemplate,
                 styles: styles,
-                orientation: orientation);
+                orientation: orientation,
+                bufferFactor: bufferFactor);
         }
 
-        private static (VirtualizingStackPanel, ScrollViewer, T) CreateTarget<T>(
+
+        private static (TStackPanel, ScrollViewer, T) CreateTarget<T, TStackPanel>(
             IEnumerable<object>? items = null,
             Optional<IDataTemplate?> itemTemplate = default,
             IEnumerable<Style>? styles = null,
-            Orientation orientation = Orientation.Vertical)
+            Orientation orientation = Orientation.Vertical,
+            double bufferFactor = 0.0d)
                 where T : ItemsControl, new()
+                where TStackPanel : VirtualizingStackPanel, new()
         {
-            var (target, scroll, itemsControl) = CreateUnrootedTarget<T>(items, itemTemplate, orientation);
+            var (target, scroll, itemsControl) = CreateUnrootedTarget<T, TStackPanel>(items, itemTemplate, orientation, bufferFactor: bufferFactor);
+
             var root = CreateRoot(itemsControl, styles: styles);
 
             root.LayoutManager.ExecuteInitialLayoutPass();
@@ -1497,12 +2269,23 @@ namespace Avalonia.Controls.UnitTests
         private static (VirtualizingStackPanel, ScrollViewer, T) CreateUnrootedTarget<T>(
             IEnumerable<object>? items = null,
             Optional<IDataTemplate?> itemTemplate = default,
-            Orientation orientation = Orientation.Vertical)
+            Orientation orientation = Orientation.Vertical,
+            double bufferFactor = 0.0d)
+                where T : ItemsControl, new()
+            => CreateUnrootedTarget<T, VirtualizingStackPanel>(items, itemTemplate, orientation, bufferFactor);
+
+        private static (TStackPanel, ScrollViewer, T) CreateUnrootedTarget<T, TStackPanel>(
+            IEnumerable<object>? items = null,
+            Optional<IDataTemplate?> itemTemplate = default,
+            Orientation orientation = Orientation.Vertical,
+            double bufferFactor = 0.0d)
                 where T : ItemsControl, new()
+                where TStackPanel : VirtualizingStackPanel, new()
         {
-            var target = new VirtualizingStackPanel
+            var target = new TStackPanel
             {
                 Orientation = orientation,
+                CacheLength = bufferFactor,
             };
 
             items ??= new ObservableCollection<string>(Enumerable.Range(0, 100).Select(x => $"Item {x}"));
@@ -1680,5 +2463,87 @@ namespace Avalonia.Controls.UnitTests
                 return true;
             }
         }
+
+        private interface ICountMeasureArrangeCalls
+        {
+            int Measured { get; set; }
+            int Arranged { get; set; }
+        }
+
+        [DebuggerDisplay("{DebuggerDisplay}")]
+        private class ItemWithHeightAndMeasureArrangeCount : ItemWithHeight, ICountMeasureArrangeCalls
+        {
+            public ItemWithHeightAndMeasureArrangeCount(int index, double height = 10) : base(index, height)
+            {
+            }
+
+            public int Measured { get; set; }
+            public int Arranged { get; set; }
+
+            private string DebuggerDisplay => $"{Caption} (height: {Height} m:{Measured} a: {Arranged})";
+        }
+
+        [DebuggerDisplay("{DebuggerDisplay}")]
+        private class ItemWithWidthAndMeasureArrangeCount : ItemWithWidth, ICountMeasureArrangeCalls
+        {
+            public ItemWithWidthAndMeasureArrangeCount(int index, double width = 10) : base(index, width)
+            {
+            }
+
+            public int Measured { get; set; }
+            public int Arranged { get; set; }
+
+            private string DebuggerDisplay => $"{Caption} (width: {Width} m:{Measured} a: {Arranged})";
+        }
+
+
+        private class VirtualizingStackPanelCountingMeasureArrange : VirtualizingStackPanel
+        {
+            public int Measured { get; set; }
+            public int Arranged { get; set; }
+
+            public void ResetMeasureArrangeCounters()
+            {
+                // reset counters
+                Measured = 0;
+                Arranged = 0;
+                foreach (var itm in Items.OfType<ICountMeasureArrangeCalls>())
+                {
+                    itm.Measured = 0;
+                    itm.Arranged = 0;
+                }
+            }
+
+            protected override Size MeasureOverride(Size availableSize)
+            {
+                Measured++;
+                return base.MeasureOverride(availableSize);
+            }
+
+            protected override Size ArrangeOverride(Size finalSize)
+            {
+                Arranged++;
+                return base.ArrangeOverride(finalSize);
+            }
+        }
+
+        private class CanvasCountingMeasureArrangeCalls : Canvas
+        {
+            protected override Size MeasureOverride(Size availableSize)
+            {
+                if(DataContext is ICountMeasureArrangeCalls itm)
+                    itm.Measured++;
+
+                return base.MeasureOverride(availableSize);
+            }
+
+            protected override Size ArrangeOverride(Size finalSize)
+            {
+                if(DataContext is ICountMeasureArrangeCalls itm)
+                    itm.Arranged++;
+
+                return base.ArrangeOverride(finalSize);
+            }
+        }
     }
 }