diff --git a/.github/workflows/publish-me-nuget.yml b/.github/workflows/publish-me-nuget.yml
new file mode 100644
index 000000000000..180548f8f76f
--- /dev/null
+++ b/.github/workflows/publish-me-nuget.yml
@@ -0,0 +1,59 @@
+# ModelingEvolution fork: publishes ModelingEvolution.MudBlazor on tags "me/X.Y.Z[.N]".
+# Upstream's deploy-mudblazor-nuget.yml fires on "v*" tags only, so the two never collide.
+name: publish-me-nuget
+
+on:
+  push:
+    tags:
+      - "me/[0-9]+.[0-9]+.[0-9]+*"
+
+env:
+  NUGET_PACKAGES: ${{ github.workspace }}/.nuget/packages
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Get version
+        id: version
+        run: echo "VERSION=${GITHUB_REF_NAME#me/}" >> $GITHUB_OUTPUT
+
+      - name: Setup .NET
+        uses: actions/setup-dotnet@v4
+        with:
+          global-json-file: global.json
+
+      - name: Restore
+        working-directory: src/MudBlazor
+        run: dotnet restore
+
+      - name: Pack
+        working-directory: src/MudBlazor
+        run: dotnet pack -c Release --no-restore --output nupkgs /p:Version=${{ steps.version.outputs.VERSION }}
+
+      - name: Check package contains css
+        shell: pwsh
+        run: ./tools/CheckPackageContainsStaticAssets.ps1 ./src/MudBlazor/nupkgs MudBlazor.min.css
+
+      - name: Check package contains js
+        shell: pwsh
+        run: ./tools/CheckPackageContainsStaticAssets.ps1 ./src/MudBlazor/nupkgs MudBlazor.min.js
+
+      - name: Push to ModelingEvolution NuGet
+        working-directory: src/MudBlazor
+        run: |
+          dotnet nuget push nupkgs/*.nupkg \
+            --api-key ${{ secrets.NUGET_API_KEY_ME }} \
+            --source https://nuget.modelingevolution.com/v3/index.json \
+            --skip-duplicate
+        continue-on-error: true
+
+      - name: Push to NuGet.org
+        working-directory: src/MudBlazor
+        run: |
+          dotnet nuget push nupkgs/*.nupkg \
+            --api-key ${{ secrets.NUGET_API_KEY }} \
+            --source https://api.nuget.org/v3/index.json \
+            --skip-duplicate
diff --git a/src/MudBlazor.UnitTests.Viewer/TestComponents/DatePicker/DateRangePickerMinMaxDaysTest.razor b/src/MudBlazor.UnitTests.Viewer/TestComponents/DatePicker/DateRangePickerMinMaxDaysTest.razor
index e9c069e962d1..018626c8db4b 100644
--- a/src/MudBlazor.UnitTests.Viewer/TestComponents/DatePicker/DateRangePickerMinMaxDaysTest.razor
+++ b/src/MudBlazor.UnitTests.Viewer/TestComponents/DatePicker/DateRangePickerMinMaxDaysTest.razor
@@ -9,7 +9,7 @@
     AdditionalDateClassesFunc="@((DateTime dt)=>((int)dt.DayOfWeek == 0 ? "red-text text-accent-4" : ""))" />
 
     <MudStack Row>
-        <MudSwitch @bind-Value="AllowWeekends" @bind-Value:after="@(() => _picker.RecalculateValidDays())" Color="Color.Primary">Allow Weekends</MudSwitch>
+        <MudSwitch @bind-Value="AllowWeekends" @bind-Value:after="@(() => _picker?.RecalculateValidDays())" Color="Color.Primary">Allow Weekends</MudSwitch>
         <MudSwitch @bind-Value="CountDisabledDays" Color="Color.Primary">Include Disabled</MudSwitch>
     </MudStack>
 
diff --git a/src/MudBlazor.UnitTests.Viewer/TestComponents/Table/TableAutoReloadTest.razor b/src/MudBlazor.UnitTests.Viewer/TestComponents/Table/TableAutoReloadTest.razor
new file mode 100644
index 000000000000..073f0c878aec
--- /dev/null
+++ b/src/MudBlazor.UnitTests.Viewer/TestComponents/Table/TableAutoReloadTest.razor
@@ -0,0 +1,64 @@
+@using System.Collections.Specialized
+@using System.ComponentModel
+
+<MudTable T="Item" Items="Source" AutoReloadOnCollectionChanged="AutoReloadOnCollectionChanged" AutoReloadOnItemPropertyChanged="AutoReloadOnItemPropertyChanged">
+    <HeaderContent>
+        <MudTh>Name</MudTh>
+    </HeaderContent>
+    <RowTemplate>
+        <MudTd>@context.Name</MudTd>
+    </RowTemplate>
+</MudTable>
+
+@code {
+    public static string __description__ = "AutoReloadOnCollectionChanged / AutoReloadOnItemPropertyChanged re-render the table from INotifyCollectionChanged / INotifyPropertyChanged without reassigning Items.";
+
+    [Parameter] public bool AutoReloadOnCollectionChanged { get; set; }
+    [Parameter] public bool AutoReloadOnItemPropertyChanged { get; set; }
+    [Parameter] public TrackedCollection Source { get; set; } = new() { new Item("a"), new Item("b"), new Item("c") };
+
+    /// <summary>An item that counts its PropertyChanged subscribers so tests can prove unsubscription.</summary>
+    public sealed class Item(string name) : INotifyPropertyChanged
+    {
+        private string _name = name;
+        private PropertyChangedEventHandler? _propertyChanged;
+
+        public int SubscriberCount { get; private set; }
+
+        public string Name
+        {
+            get => _name;
+            set
+            {
+                _name = value;
+                _propertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Name)));
+            }
+        }
+
+        public event PropertyChangedEventHandler? PropertyChanged
+        {
+            add { _propertyChanged += value; SubscriberCount++; }
+            remove { _propertyChanged -= value; SubscriberCount--; }
+        }
+    }
+
+    /// <summary>An ObservableCollection that counts its CollectionChanged subscribers.</summary>
+    public sealed class TrackedCollection : System.Collections.ObjectModel.ObservableCollection<Item>, INotifyCollectionChanged
+    {
+        private NotifyCollectionChangedEventHandler? _handler;
+
+        public int SubscriberCount { get; private set; }
+
+        event NotifyCollectionChangedEventHandler? INotifyCollectionChanged.CollectionChanged
+        {
+            add { _handler += value; SubscriberCount++; }
+            remove { _handler -= value; SubscriberCount--; }
+        }
+
+        protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
+        {
+            base.OnCollectionChanged(e);
+            _handler?.Invoke(this, e);
+        }
+    }
+}
diff --git a/src/MudBlazor.UnitTests/Components/TableAutoReloadTests.cs b/src/MudBlazor.UnitTests/Components/TableAutoReloadTests.cs
new file mode 100644
index 000000000000..b1a02f8b626d
--- /dev/null
+++ b/src/MudBlazor.UnitTests/Components/TableAutoReloadTests.cs
@@ -0,0 +1,225 @@
+using AwesomeAssertions;
+using Bunit;
+using MudBlazor.UnitTests.TestComponents.Table;
+using NUnit.Framework;
+
+namespace MudBlazor.UnitTests.Components
+{
+    /// <summary>
+    /// <see cref="MudTable{T}.AutoReloadOnCollectionChanged"/> and <see cref="MudTable{T}.AutoReloadOnItemPropertyChanged"/>:
+    /// opt-in re-rendering from INotifyCollectionChanged / INotifyPropertyChanged, parity with MudDataGrid (#11822).
+    /// </summary>
+    [TestFixture]
+    public class TableAutoReloadTests : BunitTest
+    {
+        private static int RowCount(IRenderedComponent<TableAutoReloadTest> comp) => comp.FindAll("tbody tr.mud-table-row").Count;
+
+        [Test]
+        public void Default_DoesNotSubscribe_AndDoesNotRerenderOnAdd()
+        {
+            var comp = Context.Render<TableAutoReloadTest>();
+            var source = comp.Instance.Source;
+            RowCount(comp).Should().Be(3);
+            source.SubscriberCount.Should().Be(0, "both flags default to false → upstream behaviour is unchanged");
+            source[0].SubscriberCount.Should().Be(0);
+
+            var renders = comp.RenderCount;
+            source.Add(new TableAutoReloadTest.Item("d"));
+            Thread.Sleep(50);
+            comp.RenderCount.Should().Be(renders);
+            RowCount(comp).Should().Be(3, "without opt-in the table only repaints when its parent re-renders");
+        }
+
+        [Test]
+        public void CollectionChanged_On_RerendersOnAddRemoveClear()
+        {
+            var comp = Context.Render<TableAutoReloadTest>(p => p.Add(x => x.AutoReloadOnCollectionChanged, true));
+            var source = comp.Instance.Source;
+            source.SubscriberCount.Should().Be(1);
+
+            source.Add(new TableAutoReloadTest.Item("d"));
+            comp.WaitForAssertion(() => RowCount(comp).Should().Be(4));
+
+            source.RemoveAt(0);
+            comp.WaitForAssertion(() => RowCount(comp).Should().Be(3));
+            comp.Markup.Should().NotContain(">a<");
+
+            source.Clear();
+            comp.WaitForAssertion(() => RowCount(comp).Should().Be(0));
+        }
+
+        [Test]
+        public void CollectionChanged_On_DoesNotObserveItemProperties()
+        {
+            var comp = Context.Render<TableAutoReloadTest>(p => p.Add(x => x.AutoReloadOnCollectionChanged, true));
+            var item = comp.Instance.Source[0];
+            item.SubscriberCount.Should().Be(0);
+
+            var renders = comp.RenderCount;
+            item.Name = "changed";
+            Thread.Sleep(50);
+            comp.RenderCount.Should().Be(renders);
+        }
+
+        [Test]
+        public void ItemPropertyChanged_On_RerendersOnPropertyChange()
+        {
+            var comp = Context.Render<TableAutoReloadTest>(p => p.Add(x => x.AutoReloadOnItemPropertyChanged, true));
+            var item = comp.Instance.Source[1];
+            item.SubscriberCount.Should().Be(1);
+
+            item.Name = "renamed";
+            comp.WaitForAssertion(() => comp.Markup.Should().Contain("renamed"));
+        }
+
+        [Test]
+        public void ItemPropertyChanged_On_ObservesOnlyRenderedRows_AndFollowsRowLifecycle()
+        {
+            var comp = Context.Render<TableAutoReloadTest>(p => p
+                .Add(x => x.AutoReloadOnCollectionChanged, true)
+                .Add(x => x.AutoReloadOnItemPropertyChanged, true));
+            var source = comp.Instance.Source;
+
+            // A row exists per item on the page → each is observed once.
+            source.Should().OnlyContain(i => i.SubscriberCount == 1);
+
+            // Added item: observed as soon as its row renders …
+            var added = new TableAutoReloadTest.Item("d");
+            source.Add(added);
+            comp.WaitForAssertion(() => added.SubscriberCount.Should().Be(1));
+            added.Name = "d2";
+            comp.WaitForAssertion(() => comp.Markup.Should().Contain("d2"));
+
+            // … removed item: its row is disposed and the subscription goes with it.
+            var removed = source[0];
+            source.RemoveAt(0);
+            comp.WaitForAssertion(() => removed.SubscriberCount.Should().Be(0));
+            RowCount(comp).Should().Be(3);
+        }
+
+        [Test]
+        public void ItemPropertyChanged_On_RerendersOnlyThatRow()
+        {
+            var comp = Context.Render<TableAutoReloadTest>(p => p.Add(x => x.AutoReloadOnItemPropertyChanged, true));
+            var rows = comp.FindComponents<MudTr>();
+            Thread.Sleep(200);                       // let the table finish its own post-render settling
+            var before = rows.Select(r => r.RenderCount).ToArray();
+
+            comp.Instance.Source[2].Name = "only-me";
+            comp.WaitForAssertion(() => comp.Markup.Should().Contain("only-me"));
+
+            // bUnit bumps RenderCount on every ancestor whose markup changed, so the table's count is not
+            // evidence either way; sibling rows are — they must not have been rendered again.
+            rows[0].RenderCount.Should().Be(before[0]);
+            rows[1].RenderCount.Should().Be(before[1]);
+            rows[2].RenderCount.Should().BeGreaterThan(before[2]);
+        }
+
+        [Test]
+        public void ItemPropertyChanged_Burst_IsCoalescedPerRow()
+        {
+            var comp = Context.Render<TableAutoReloadTest>(p => p.Add(x => x.AutoReloadOnItemPropertyChanged, true));
+            var item = comp.Instance.Source[0];
+            var renders = comp.RenderCount;
+
+            comp.InvokeAsync(() =>
+            {
+                for (var i = 0; i < 500; i++)
+                {
+                    item.Name = $"n{i}";
+                }
+            });
+
+            comp.WaitForAssertion(() => comp.Markup.Should().Contain("n499"));
+            (comp.RenderCount - renders).Should().BeLessThan(10);
+        }
+
+        [Test]
+        public void Burst_IsCoalescedIntoFewRenders()
+        {
+            var comp = Context.Render<TableAutoReloadTest>(p => p.Add(x => x.AutoReloadOnCollectionChanged, true));
+            var source = comp.Instance.Source;
+            var renders = comp.RenderCount;
+
+            comp.InvokeAsync(() =>
+            {
+                for (var i = 0; i < 500; i++)
+                {
+                    source.Add(new TableAutoReloadTest.Item($"i{i}"));
+                }
+            });
+
+            comp.WaitForAssertion(() => RowCount(comp).Should().Be(503));
+            (comp.RenderCount - renders).Should().BeLessThan(10, "500 notifications must not schedule 500 renders");
+        }
+
+        [Test]
+        public async Task Items_Swapped_MovesSubscriptionsToNewCollection()
+        {
+            var comp = Context.Render<TableAutoReloadTest>(p => p
+                .Add(x => x.AutoReloadOnCollectionChanged, true)
+                .Add(x => x.AutoReloadOnItemPropertyChanged, true));
+            var old = comp.Instance.Source;
+            old.SubscriberCount.Should().Be(1);
+            old[0].SubscriberCount.Should().Be(1);
+
+            var next = new TableAutoReloadTest.TrackedCollection { new TableAutoReloadTest.Item("x") };
+            await comp.SetParametersAndRenderAsync(p => p.Add(x => x.Source, next));
+
+            old.SubscriberCount.Should().Be(0);
+            old[0].SubscriberCount.Should().Be(0);
+            next.SubscriberCount.Should().Be(1);
+            next[0].SubscriberCount.Should().Be(1);
+            RowCount(comp).Should().Be(1);
+        }
+
+        [Test]
+        public async Task Flags_TurnedOff_Unsubscribe()
+        {
+            var comp = Context.Render<TableAutoReloadTest>(p => p
+                .Add(x => x.AutoReloadOnCollectionChanged, true)
+                .Add(x => x.AutoReloadOnItemPropertyChanged, true));
+            var source = comp.Instance.Source;
+
+            await comp.SetParametersAndRenderAsync(p => p
+                .Add(x => x.AutoReloadOnCollectionChanged, false)
+                .Add(x => x.AutoReloadOnItemPropertyChanged, false));
+
+            source.SubscriberCount.Should().Be(0);
+            source.Should().OnlyContain(i => i.SubscriberCount == 0);
+        }
+
+        [Test]
+        public async Task Dispose_Unsubscribes_AndLateNotificationsAreIgnored()
+        {
+            var comp = Context.Render<TableAutoReloadTest>(p => p
+                .Add(x => x.AutoReloadOnCollectionChanged, true)
+                .Add(x => x.AutoReloadOnItemPropertyChanged, true));
+            var source = comp.Instance.Source;
+            source.SubscriberCount.Should().Be(1);
+
+            await Context.DisposeComponentsAsync();
+
+            source.SubscriberCount.Should().Be(0);
+            source.Should().OnlyContain(i => i.SubscriberCount == 0);
+            var act = () => { source.Add(new TableAutoReloadTest.Item("late")); source[0].Name = "late"; };
+            act.Should().NotThrow();
+        }
+
+        [Test]
+        public void Clear_DisposesRows_AndReleasesItemSubscriptions()
+        {
+            var comp = Context.Render<TableAutoReloadTest>(p => p
+                .Add(x => x.AutoReloadOnCollectionChanged, true)
+                .Add(x => x.AutoReloadOnItemPropertyChanged, true));
+            var source = comp.Instance.Source;
+            var items = source.ToList();
+            items.Should().OnlyContain(i => i.SubscriberCount == 1);
+
+            source.Clear();   // Reset: no OldItems — the row lifecycle, not event args, releases the subscriptions
+
+            comp.WaitForAssertion(() => RowCount(comp).Should().Be(0));
+            comp.WaitForAssertion(() => items.Should().OnlyContain(i => i.SubscriberCount == 0));
+        }
+    }
+}
diff --git a/src/MudBlazor/Components/Table/MudTable.razor b/src/MudBlazor/Components/Table/MudTable.razor
index 8c288e1af043..4eda4370d2a7 100644
--- a/src/MudBlazor/Components/Table/MudTable.razor
+++ b/src/MudBlazor/Components/Table/MudTable.razor
@@ -101,6 +101,7 @@
                             if (CurrentPageItems != null && CurrentPageItems.Any())
                             {
                                 <MudVirtualize Enabled="@Virtualize" Items="@CurrentPageItems?.ToList()" OverscanCount="@OverscanCount" ItemSize="@ItemSize" Context="item">
+                                    @ObservedRow(item, @<text>
                                     @{
                                         var itemIndex = FilteredItems.ToList().IndexOf(item);
                                         var generatedRowId = itemIndex != -1 ? $"{_tableId}_row_{itemIndex}" : null;
@@ -110,7 +111,7 @@
                                             .Build();
                                         var rowStyle = new StyleBuilder().AddStyle(RowStyle).AddStyle(RowStyleFunc?.Invoke(item, itemIndex)).Build();
                                     }
-                                    <MudTr Class="@rowClass" Style="@rowStyle" Item="item" @key="item" RowId="@generatedRowId"
+                                    <MudTr Class="@rowClass" Style="@rowStyle" Item="item" RowId="@generatedRowId"
                                            Checkable="MultiSelection" SelectionChangeable="SelectionChangeable" Editable="IsItemEditable(item)"
                                            Disabled="IsRowDisabled(item)" DisabledClass="@DisabledRowClass" Checked="@(IsCheckedRow(item))"
                                            CheckedChanged="@(value => OnRowCheckboxChanged(value, item))">
@@ -144,6 +145,7 @@
                                     {
                                         @ChildRowContent(item)
                                     }
+                                    </text>)
                                 </MudVirtualize>
                             }
                         }
@@ -216,7 +218,9 @@
                  <MudVirtualize Enabled="@Virtualize" Items="@source?.ToList()" OverscanCount="@OverscanCount" ItemSize="@ItemSize" Context="item" ChildContent="@child()"/>
             </text>;
 
-        RenderFragment<T> child() => item =>
+        RenderFragment<T> child() => item => ObservedRow(item, rowContent()(item));
+
+        RenderFragment<T> rowContent() => item =>
             @<text>
                  @{
                      var itemIndexForId = FilteredItems.ToList().IndexOf(item);
@@ -225,7 +229,7 @@
                      var rowClass = new CssBuilder(RowClass).AddClass(RowClassFunc?.Invoke(item, itemIndexForId)).AddClass(customClass, !string.IsNullOrEmpty(customClass)).AddClass("mud-table-row-clickable", OnRowClick.HasDelegate && !IsRowDisabled(item)).Build();
                      var rowStyle = new StyleBuilder().AddStyle(RowStyle).AddStyle(RowStyleFunc?.Invoke(item, itemIndexForId)).Build();
                  }
-                 <MudTr Class="@rowClass" Style="@rowStyle" Item="item" @key="item" RowId="@generatedRowId" Checkable="MultiSelection" SelectionChangeable="SelectionChangeable"
+                 <MudTr Class="@rowClass" Style="@rowStyle" Item="item" RowId="@generatedRowId" Checkable="MultiSelection" SelectionChangeable="SelectionChangeable"
                         Editable="IsItemEditable(item)" Expandable="expandable" Disabled="IsRowDisabled(item)" DisabledClass="@DisabledRowClass"
                         Checked="Context.Selection.Contains(item)" CheckedChanged="((value) => { OnRowCheckboxChanged(value, item); })">
                      @if (!ReadOnly && Editable && Equals(_editingItem, item))
diff --git a/src/MudBlazor/Components/Table/MudTable.razor.cs b/src/MudBlazor/Components/Table/MudTable.razor.cs
index cc385ef4ccb4..d9b71a17a719 100644
--- a/src/MudBlazor/Components/Table/MudTable.razor.cs
+++ b/src/MudBlazor/Components/Table/MudTable.razor.cs
@@ -1,4 +1,6 @@
-using System.Diagnostics.CodeAnalysis;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
 using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.Components.Web;
 using Microsoft.JSInterop;
@@ -30,6 +32,9 @@ public partial class MudTable<[DynamicallyAccessedMembers(DynamicallyAccessedMem
         private bool _currentRenderFilteredItemsCached;
         private CancellationTokenSource? _cancellationTokenSrc;
         private TableData<T> _serverData = new() { TotalItems = 0, Items = [] };
+        private INotifyCollectionChanged? _observedCollection;
+        private int _autoReloadPending;
+        private bool _disposed;
 
         [MemberNotNullWhen(true, nameof(_preEditSort))]
         private bool HasPreEditSort => _preEditSort is not null;
@@ -240,6 +245,33 @@ public IEnumerable<T>? Items
             }
         }
 
+        /// <summary>
+        /// Re-renders this table when <see cref="Items"/> raises <see cref="INotifyCollectionChanged.CollectionChanged"/>.
+        /// </summary>
+        /// <remarks>
+        /// Defaults to <c>false</c>.  When <c>true</c> and <see cref="Items"/> implements <see cref="INotifyCollectionChanged"/>
+        /// (such as <c>ObservableCollection&lt;T&gt;</c>), adding, removing or replacing items refreshes the table without
+        /// reassigning <see cref="Items"/> or calling <c>StateHasChanged</c>.  Bursts of changes are coalesced into one render.
+        /// The event may be raised on any thread; the render is dispatched to the component's synchronization context.
+        /// Has no effect when <see cref="ServerData"/> is set.
+        /// </remarks>
+        [Parameter]
+        [Category(CategoryTypes.Table.Behavior)]
+        public bool AutoReloadOnCollectionChanged { get; set; }
+
+        /// <summary>
+        /// Re-renders this table when an item in <see cref="Items"/> raises <see cref="INotifyPropertyChanged.PropertyChanged"/>.
+        /// </summary>
+        /// <remarks>
+        /// Defaults to <c>false</c>.  When <c>true</c>, each rendered row observes its own item for as long as the row exists
+        /// (rows are keyed on the item), and a change re-renders that row only.  Items not currently rendered — other pages,
+        /// outside the virtualized window — are not observed, so cost is bounded by visible rows, not by the collection.
+        /// Bursts of changes are coalesced into one render per row.
+        /// </remarks>
+        [Parameter]
+        [Category(CategoryTypes.Table.Behavior)]
+        public bool AutoReloadOnItemPropertyChanged { get; set; }
+
         /// <summary>
         /// The function which determines whether an item should be displayed.
         /// </summary>
@@ -918,6 +950,70 @@ private string ClearFilterCache()
             return "";
         }
 
+        /// <inheritdoc/>
+        protected override void OnParametersSet()
+        {
+            base.OnParametersSet();
+            UpdateAutoReloadSubscriptions();
+        }
+
+        //AUTO RELOAD (INotifyCollectionChanged; per-item INotifyPropertyChanged lives in MudTableObservedRow<T>):
+
+        /// <summary>
+        /// Wraps one row in a <see cref="MudTableObservedRow{T}"/> scope keyed on the item.  Rendered from code because
+        /// the component is internal and Razor tag syntax only discovers public component types.
+        /// </summary>
+        private RenderFragment ObservedRow(T item, RenderFragment content) => builder =>
+        {
+            builder.OpenComponent<MudTableObservedRow<T>>(0);
+            builder.SetKey(item);
+            builder.AddComponentParameter(1, nameof(MudTableObservedRow<T>.Item), item);
+            builder.AddComponentParameter(2, nameof(MudTableObservedRow<T>.Enabled), AutoReloadOnItemPropertyChanged);
+            builder.AddComponentParameter(3, nameof(MudTableObservedRow<T>.ChildContent), content);
+            builder.CloseComponent();
+        };
+
+        private void UpdateAutoReloadSubscriptions()
+        {
+            var wanted = !HasServerData && AutoReloadOnCollectionChanged ? _items as INotifyCollectionChanged : null;
+            if (ReferenceEquals(_observedCollection, wanted))
+            {
+                return;
+            }
+
+            if (_observedCollection is not null)
+            {
+                _observedCollection.CollectionChanged -= OnObservedCollectionChanged;
+            }
+
+            _observedCollection = wanted;
+
+            if (wanted is not null)
+            {
+                wanted.CollectionChanged += OnObservedCollectionChanged;
+            }
+        }
+
+        private void OnObservedCollectionChanged(object? sender, NotifyCollectionChangedEventArgs e)
+        {
+            // May arrive on any thread.  Render on the next dispatcher turn, once for any number of notifications
+            // that arrive before it — deferring past the current turn is what coalesces a synchronous burst.
+            if (_disposed || Interlocked.CompareExchange(ref _autoReloadPending, 1, 0) != 0)
+            {
+                return;
+            }
+
+            InvokeAsync(async () =>
+            {
+                await Task.Yield();
+                Interlocked.Exchange(ref _autoReloadPending, 0);
+                if (!_disposed)
+                {
+                    StateHasChanged();
+                }
+            });
+        }
+
         /// <summary>
         /// Releases resources used by this table.
         /// </summary>
@@ -929,6 +1025,13 @@ public void Dispose()
 
         protected virtual void Dispose(bool disposing)
         {
+            _disposed = true;
+            if (_observedCollection is not null)
+            {
+                _observedCollection.CollectionChanged -= OnObservedCollectionChanged;
+                _observedCollection = null;
+            }
+
             try
             {
                 _cancellationTokenSrc?.Cancel();
diff --git a/src/MudBlazor/Components/Table/MudTableObservedRow.cs b/src/MudBlazor/Components/Table/MudTableObservedRow.cs
new file mode 100644
index 000000000000..1e8b511a6eef
--- /dev/null
+++ b/src/MudBlazor/Components/Table/MudTableObservedRow.cs
@@ -0,0 +1,87 @@
+using System.ComponentModel;
+using Microsoft.AspNetCore.Components;
+using Microsoft.AspNetCore.Components.Rendering;
+
+namespace MudBlazor;
+
+/// <summary>
+/// Internal per-row scope for <see cref="MudTable{T}.AutoReloadOnItemPropertyChanged"/>: observes one item's
+/// <see cref="INotifyPropertyChanged.PropertyChanged"/> for exactly as long as the row exists, and re-renders
+/// only this row when it fires.  Blazor's row lifecycle (keyed on the item) is the bookkeeping: a row that
+/// leaves the page, the virtualized window, or the table is disposed and its subscription goes with it — so
+/// there is no per-table set of subscribed items and nothing to reconcile on <c>Reset</c>.
+/// </summary>
+/// <typeparam name="T">The item type.</typeparam>
+internal sealed class MudTableObservedRow<T> : ComponentBase, IDisposable
+{
+    private INotifyPropertyChanged? _observed;
+    private int _renderPending;
+    private bool _disposed;
+
+    /// <summary>The row's item.</summary>
+    [Parameter]
+    public T Item { get; set; } = default!;
+
+    /// <summary>When <c>false</c>, nothing is observed and the row renders exactly as without this scope.</summary>
+    [Parameter]
+    public bool Enabled { get; set; }
+
+    /// <summary>The row content.</summary>
+    [Parameter]
+    public RenderFragment? ChildContent { get; set; }
+
+    /// <inheritdoc/>
+    protected override void OnParametersSet()
+    {
+        var wanted = Enabled ? Item as INotifyPropertyChanged : null;
+        if (ReferenceEquals(_observed, wanted))
+        {
+            return;
+        }
+
+        if (_observed is not null)
+        {
+            _observed.PropertyChanged -= OnItemPropertyChanged;
+        }
+
+        _observed = wanted;
+
+        if (wanted is not null)
+        {
+            wanted.PropertyChanged += OnItemPropertyChanged;
+        }
+    }
+
+    /// <inheritdoc/>
+    protected override void BuildRenderTree(RenderTreeBuilder builder) => builder.AddContent(0, ChildContent);
+
+    private void OnItemPropertyChanged(object? sender, PropertyChangedEventArgs e)
+    {
+        // May arrive on any thread; render on the next dispatcher turn, once per burst.
+        if (_disposed || Interlocked.CompareExchange(ref _renderPending, 1, 0) != 0)
+        {
+            return;
+        }
+
+        _ = InvokeAsync(async () =>
+        {
+            await Task.Yield();
+            Interlocked.Exchange(ref _renderPending, 0);
+            if (!_disposed)
+            {
+                StateHasChanged();
+            }
+        });
+    }
+
+    /// <inheritdoc/>
+    public void Dispose()
+    {
+        _disposed = true;
+        if (_observed is not null)
+        {
+            _observed.PropertyChanged -= OnItemPropertyChanged;
+            _observed = null;
+        }
+    }
+}
diff --git a/src/MudBlazor/MudBlazor.csproj b/src/MudBlazor/MudBlazor.csproj
index 9c850c615ef4..ddf9520afbc2 100644
--- a/src/MudBlazor/MudBlazor.csproj
+++ b/src/MudBlazor/MudBlazor.csproj
@@ -6,6 +6,15 @@
     <EnumGenerator_ForceInternal>true</EnumGenerator_ForceInternal>
   </PropertyGroup>
 
+  <!-- ModelingEvolution fork: published as ModelingEvolution.MudBlazor, a drop-in for MudBlazor.
+       Assembly name, root namespace and the static-asset base path (_content/MudBlazor/) stay
+       "MudBlazor" so consumers swap ONE PackageReference and change nothing else. -->
+  <PropertyGroup>
+    <PackageId>ModelingEvolution.MudBlazor</PackageId>
+    <AssemblyName>MudBlazor</AssemblyName>
+    <RootNamespace>MudBlazor</RootNamespace>
+    <StaticWebAssetBasePath>_content/MudBlazor</StaticWebAssetBasePath>
+  </PropertyGroup>
   <PropertyGroup>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>
     <PackageIcon>Nuget.png</PackageIcon>
@@ -13,10 +22,10 @@
     <Authors>Garderoben, Henon and Contributors</Authors>
     <Copyright>Copyright 2026 MudBlazor</Copyright>
     <PackageTags>Blazor, MudBlazor, Material, Material Design, Components, Blazor Components, Blazor Library</PackageTags>
-    <Description>Blazor Component Library based on Material Design principles with an emphasis on ease of use and extensibility</Description>
+    <Description>ModelingEvolution fork of MudBlazor (drop-in, same namespaces and asset paths). Adds MudTable.AutoReloadOnCollectionChanged / AutoReloadOnItemPropertyChanged. Upstream: https://github.com/MudBlazor/MudBlazor</Description>
     <PackageProjectUrl>https://mudblazor.com/</PackageProjectUrl>
     <PackageReadmeFile>README.md</PackageReadmeFile>
-    <RepositoryUrl>https://github.com/MudBlazor/MudBlazor</RepositoryUrl>
+    <RepositoryUrl>https://github.com/modelingevolution/MudBlazor</RepositoryUrl>
     <RepositoryType>git</RepositoryType>
   </PropertyGroup>
   
@@ -44,6 +53,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <None Include="buildTransitive\ModelingEvolution.MudBlazor.targets" Pack="true" PackagePath="buildTransitive\" />
     <None Include="..\..\LICENSE" Pack="true" Visible="false" PackagePath="" />
     <None Include="..\..\README.md" Pack="true" Visible="false" PackagePath="" />
     <None Include="..\..\content\Nuget.png" Pack="true" Visible="false" PackagePath="" />
diff --git a/src/MudBlazor/buildTransitive/ModelingEvolution.MudBlazor.targets b/src/MudBlazor/buildTransitive/ModelingEvolution.MudBlazor.targets
new file mode 100644
index 000000000000..c371ee11ff12
--- /dev/null
+++ b/src/MudBlazor/buildTransitive/ModelingEvolution.MudBlazor.targets
@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ModelingEvolution.MudBlazor is a drop-in for the upstream MudBlazor package: same assembly name (MudBlazor.dll), same
+  namespaces, same static-asset path (_content/MudBlazor). A consumer that ALSO receives the upstream package — almost
+  always transitively, through a library such as MudBlazor.Markdown or Extensions.MudBlazor.StaticInput — would get two
+  MudBlazor.dll and two _content/MudBlazor/MudBlazor.min.css ("Conflicting assets with the same target path").
+
+  This file is imported by every project that references ModelingEvolution.MudBlazor directly OR transitively
+  (buildTransitive), and removes the upstream package's contribution so that exactly one MudBlazor ships: ours.
+  The upstream package stays in the dependency graph (its dependents still resolve); only its assets are dropped.
+  Opt out with <ModelingEvolutionMudBlazorSupersedesUpstream>false</...> in the consuming project.
+-->
+<Project>
+  <PropertyGroup>
+    <ModelingEvolutionMudBlazorSupersedesUpstream Condition="'$(ModelingEvolutionMudBlazorSupersedesUpstream)' == ''">true</ModelingEvolutionMudBlazorSupersedesUpstream>
+  </PropertyGroup>
+
+  <!-- Compile-time and runtime assets of the upstream package: resolved by ResolvePackageAssets from project.assets.json. -->
+  <Target Name="_MeMudBlazorDropUpstreamPackageAssets"
+          AfterTargets="ResolvePackageAssets"
+          Condition="'$(ModelingEvolutionMudBlazorSupersedesUpstream)' == 'true'">
+    <ItemGroup>
+      <ResolvedCompileFileDefinitions Remove="@(ResolvedCompileFileDefinitions)" Condition="'%(ResolvedCompileFileDefinitions.NuGetPackageId)' == 'MudBlazor'" />
+      <RuntimeCopyLocalItems Remove="@(RuntimeCopyLocalItems)" Condition="'%(RuntimeCopyLocalItems.NuGetPackageId)' == 'MudBlazor'" />
+      <ResourceCopyLocalItems Remove="@(ResourceCopyLocalItems)" Condition="'%(ResourceCopyLocalItems.NuGetPackageId)' == 'MudBlazor'" />
+      <RuntimeTargetsCopyLocalItems Remove="@(RuntimeTargetsCopyLocalItems)" Condition="'%(RuntimeTargetsCopyLocalItems.NuGetPackageId)' == 'MudBlazor'" />
+      <ResolvedAnalyzers Remove="@(ResolvedAnalyzers)" Condition="'%(ResolvedAnalyzers.NuGetPackageId)' == 'MudBlazor'" />
+    </ItemGroup>
+  </Target>
+
+  <!-- Static web assets of the upstream package: declared as StaticWebAsset items by its build/*.props at evaluation
+       time (SourceId = the package id); drop them before the SWA pipeline resolves inputs and detects the conflict. -->
+  <Target Name="_MeMudBlazorDropUpstreamStaticWebAssets"
+          BeforeTargets="ResolveStaticWebAssetsInputs;ResolveStaticWebAssetsConfiguration;ResolveReferencedProjectsStaticWebAssets;ResolveProjectStaticWebAssets"
+          Condition="'$(ModelingEvolutionMudBlazorSupersedesUpstream)' == 'true'">
+    <ItemGroup>
+      <StaticWebAsset Remove="@(StaticWebAsset)" Condition="'%(StaticWebAsset.SourceId)' == 'MudBlazor'" />
+      <StaticWebAssetEndpoint Remove="@(StaticWebAssetEndpoint)" Condition="'%(StaticWebAssetEndpoint.AssetFile)' != '' And $([System.String]::Copy('%(StaticWebAssetEndpoint.AssetFile)').Contains('/mudblazor/'))" />
+    </ItemGroup>
+  </Target>
+</Project>