diff --git a/Radzen.Blazor.Tests/DialogServiceTests.cs b/Radzen.Blazor.Tests/DialogServiceTests.cs
index 9476a4b7ebb..5a7c332b38e 100644
--- a/Radzen.Blazor.Tests/DialogServiceTests.cs
+++ b/Radzen.Blazor.Tests/DialogServiceTests.cs
@@ -1,11 +1,15 @@
-using System;
+using Bunit;
+using Microsoft.AspNetCore.Components;
+using Microsoft.Extensions.DependencyInjection;
+using System;
+using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
 using Xunit;
 
 namespace Radzen.Blazor.Tests
 {
-	public class DialogServiceTests
+	public class DialogServiceTests : ComponentBase
 	{
 		public class OpenDialogTests
 		{
@@ -124,13 +128,81 @@ public async Task OpenAsync_DynamicComponentType_Reflective_Calls_Resolve()
                 var openTask = dialogService.OpenAsync("Dynamic Open", typeof(RadzenButton), []);
                 dialogService.Close();
                 await openTask;
-                
+
                 // Assert
                 Assert.Equal("Dynamic Open", resultingTitle);
                 Assert.Equal(typeof(RadzenButton), resultingType);
             }
 		}
 
+        public class OpenSideDialogTests
+        {
+            [Fact(DisplayName = "SideDialogOptions resizable option is retained after OpenSideDialog call")]
+            public void SideDialogOptions_Resizable_AreRetained_AfterOpenSideDialogCall()
+            {
+                // Arrange
+                var options = new SideDialogOptions { Resizable = true };
+                SideDialogOptions resultingOptions = null;
+                var dialogService = new DialogService(null, null);
+                dialogService.OnSideOpen += (_, _, sideOptions) => resultingOptions = sideOptions;
+
+                // Act
+                dialogService.OpenSide<DialogServiceTests>("Test", [], options);
+
+                // Assert
+                Assert.NotNull(resultingOptions);
+                Assert.Same(options, resultingOptions);
+                Assert.True(resultingOptions.Resizable);
+            }
+
+            [Fact(DisplayName = "Side dialog shows resize bar when Resizable is true")]
+            public void SideDialog_Resizable_ShowsResizeBar()
+            {
+                using var ctx = new TestContext();
+                ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+                ctx.Services.AddScoped<DialogService>();
+
+                // Render the dialog host
+                var cut = ctx.RenderComponent<RadzenDialog>();
+
+                // Open a side dialog with Resizable=true
+                var dialogService = ctx.Services.GetRequiredService<DialogService>();
+                cut.InvokeAsync(() => dialogService.OpenSide("Test", typeof(RadzenButton),
+                    new Dictionary<string, object>(), new SideDialogOptions { Resizable = true }));
+
+                // Assert: the resize bar element is present
+                cut.WaitForAssertion(() =>
+                {
+                    var markup = cut.Markup;
+                    Assert.Contains("rz-dialog-resize-bar", markup);
+                    // Optionally ensure the inner handle exists too
+                    Assert.Contains("rz-resize", markup);
+                });
+            }
+
+            [Fact(DisplayName = "Side dialog hides resize bar when Resizable is false")]
+            public void SideDialog_NonResizable_HidesResizeBar()
+            {
+                using var ctx = new TestContext();
+                ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+                ctx.Services.AddScoped<DialogService>();
+
+                // Render the dialog host
+                var cut = ctx.RenderComponent<RadzenDialog>();
+
+                // Open a side dialog with Resizable=false
+                var dialogService = ctx.Services.GetRequiredService<DialogService>();
+                cut.InvokeAsync(() => dialogService.OpenSide("Test", typeof(RadzenButton),
+                    new Dictionary<string, object>(), new SideDialogOptions()));
+
+                // Assert: the resize bar element is not present
+                cut.WaitForAssertion(() =>
+                {
+                    var markup = cut.Markup;
+                    Assert.DoesNotContain("rz-dialog-resize-bar", markup);
+                });
+            }
+        }
 		public class ConfirmTests
 		{
 			[Fact(DisplayName = "ConfirmOptions is null and default values are set correctly")]
diff --git a/Radzen.Blazor/DialogService.cs b/Radzen.Blazor/DialogService.cs
index a22950266e1..83800690c79 100644
--- a/Radzen.Blazor/DialogService.cs
+++ b/Radzen.Blazor/DialogService.cs
@@ -12,7 +12,7 @@
 namespace Radzen
 {
     /// <summary>
-    /// Class DialogService. Contains various methods with options to open and close dialogs. 
+    /// Class DialogService. Contains various methods with options to open and close dialogs.
     /// Should be added as scoped service in the application services and RadzenDialog should be added in application main layout.
     /// </summary>
     /// <example>
@@ -54,7 +54,7 @@ internal DotNetObjectReference<DialogService> Reference
                 return reference;
             }
         }
-        
+
         /// <summary>
         /// Gets or sets the URI helper.
         /// </summary>
@@ -384,7 +384,7 @@ public virtual Task<dynamic> OpenAsync(RenderFragment<DialogService> titleConten
             // register the cancellation token
             if (cancellationToken.HasValue)
                 cancellationToken.Value.Register(() => task.TrySetCanceled());
-            
+
             tasks.Add(task);
 
             options ??= new DialogOptions();
@@ -484,8 +484,8 @@ public void Dispose()
             options.Width = !String.IsNullOrEmpty(options.Width) ? options.Width : ""; // Width is set to 600px by default by OpenAsync
             options.Style = !String.IsNullOrEmpty(options.Style) ? options.Style : "";
             options.CssClass = !String.IsNullOrEmpty(options.CssClass) ? $"rz-dialog-confirm {options.CssClass}" : "rz-dialog-confirm";
-            options.WrapperCssClass = !String.IsNullOrEmpty(options.WrapperCssClass) ? $"rz-dialog-wrapper {options.WrapperCssClass}" : "rz-dialog-wrapper";    
-            
+            options.WrapperCssClass = !String.IsNullOrEmpty(options.WrapperCssClass) ? $"rz-dialog-wrapper {options.WrapperCssClass}" : "rz-dialog-wrapper";
+
             return await OpenAsync(title, ds =>
             {
                 RenderFragment content = b =>
@@ -578,7 +578,7 @@ public void Dispose()
             // Validate and set default values for the dialog options
             options ??= new();
             options.OkButtonText = !String.IsNullOrEmpty(options.OkButtonText) ? options.OkButtonText : "Ok";
-            options.Width = !String.IsNullOrEmpty(options.Width) ? options.Width : "";  
+            options.Width = !String.IsNullOrEmpty(options.Width) ? options.Width : "";
             options.Style = !String.IsNullOrEmpty(options.Style) ? options.Style : "";
             options.CssClass = !String.IsNullOrEmpty(options.CssClass) ? $"rz-dialog-alert {options.CssClass}" : "rz-dialog-alert";
             options.WrapperCssClass = !String.IsNullOrEmpty(options.WrapperCssClass) ? $"rz-dialog-wrapper {options.WrapperCssClass}" : "rz-dialog-wrapper";
@@ -848,6 +848,7 @@ public int CloseTabIndex
         }
 
         private RenderFragment<DialogService> titleContent;
+        private bool resizable;
 
         /// <summary>
         /// Gets or sets the title content.
@@ -865,6 +866,23 @@ public RenderFragment<DialogService> TitleContent
                 }
             }
         }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether the dialog is resizable. Set to <c>false</c> by default.
+        /// </summary>
+        /// <value><c>true</c> if resizable; otherwise, <c>false</c>.</value>
+        public bool Resizable
+        {
+            get => resizable;
+            set
+            {
+                if (resizable != value)
+                {
+                    resizable = value;
+                    OnPropertyChanged(nameof(Resizable));
+                }
+            }
+        }
     }
 
     /// <summary>
@@ -992,25 +1010,6 @@ public class DialogOptions : DialogOptionsBase
         /// </summary>
         public string IconStyle { get; set; } = "margin-right: 0.75rem";
 
-        
-        private bool resizable;
-        /// <summary>
-        /// Gets or sets a value indicating whether the dialog is resizable. Set to <c>false</c> by default.
-        /// </summary>
-        /// <value><c>true</c> if resizable; otherwise, <c>false</c>.</value>
-        public bool Resizable
-        {
-            get => resizable;
-            set
-            {
-                if (resizable != value)
-                {
-                    resizable = value;
-                    OnPropertyChanged(nameof(Resizable));
-                }
-            }
-        }
-
         private Action<Size> resize;
 
         /// <summary>
@@ -1147,7 +1146,7 @@ public RenderFragment<DialogService> ChildContent
         private bool autoFocusFirstElement = true;
 
         /// <summary>
-        /// Gets or sets a value indicating whether to focus the first focusable HTML element. 
+        /// Gets or sets a value indicating whether to focus the first focusable HTML element.
         /// </summary>
         /// <value><c>true</c> if the first focusable element is focused; otherwise, <c>false</c>. Default is <c>true</c>.</value>
         public bool AutoFocusFirstElement
@@ -1237,7 +1236,7 @@ public string CancelButtonText
     public class Dialog : INotifyPropertyChanged
     {
         private string title;
-    
+
         /// <summary>
         /// Gets or sets the title.
         /// </summary>
@@ -1326,4 +1325,4 @@ protected virtual void OnPropertyChanged(string propertyName)
             PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
         }
     }
-}
+}
\ No newline at end of file
diff --git a/Radzen.Blazor/RadzenDialog.razor b/Radzen.Blazor/RadzenDialog.razor
index 6eac3af6908..96b4d496701 100644
--- a/Radzen.Blazor/RadzenDialog.razor
+++ b/Radzen.Blazor/RadzenDialog.razor
@@ -12,10 +12,26 @@
 {
     <aside
         class="@GetSideDialogCssClass()"
+        @ref="sideDialogElement"
         tabindex="@(isSideDialogOpen ? "0" : "-1")"
         style="@GetSideDialogStyle()"
-        aria-labelledby="rz-dialog-side-label"
-        >
+        aria-labelledby="rz-dialog-side-label">
+        @if (sideDialogOptions.Resizable)
+        {
+            <div @ref="resizeBarElement"
+                 class="@GetResizeBarCssClass()"
+                 data-dir="@(sideDialogOptions.Position switch
+                           {
+                               DialogPosition.Left => "left",
+                               DialogPosition.Top => "top",
+                               DialogPosition.Bottom => "bottom",
+                               _ => "right"
+                           })"
+                 title="Drag to resize" aria-label="Resize side dialog">
+                <span class="rz-resize" aria-hidden="true"></span>
+            </div>
+
+        }
         @if (sideDialogOptions.ShowTitle)
         {
             <div class="rz-dialog-side-titlebar">
@@ -57,183 +73,3 @@
         }
     }
 }
-
-@code {
-    string SideDialogContentCssClass
-    {
-        get
-        {
-            var baseCss = "rz-dialog-side-content";
-            return string.IsNullOrEmpty(sideDialogOptions.ContentCssClass) ? baseCss : $"{baseCss} {sideDialogOptions.ContentCssClass}";
-        }
-
-    }
-    [Inject] 
-    DialogService Service { get; set; }
-
-    /// <summary>
-    /// Gets or sets the close side dialog aria label text.
-    /// </summary>
-    /// <value>The close side dialog aria label text.</value>
-    [Parameter]
-    public string CloseSideDialogAriaLabel { get; set; } = "Close side dialog";
-
-    List<Dialog> dialogs = new List<Dialog>();
-    bool isSideDialogOpen = false;
-    RenderFragment sideDialogContent;
-    SideDialogOptions sideDialogOptions;
-    Dialog sideDialog;
-
-    public async Task Open(string title, Type type, Dictionary<string, object> parameters, DialogOptions options)
-    {
-        dialogs.Add(new Dialog() { Title = title, Type = type, Parameters = parameters, Options = options });
-
-        await InvokeAsync(() => { StateHasChanged(); });
-    }
-
-    public async Task Close(dynamic result)
-    {
-        var lastDialog = dialogs.LastOrDefault();
-        if (lastDialog != null)
-        {
-            dialogs.Remove(lastDialog);
-            if (dialogs.Count==0) await JSRuntime.InvokeAsync<string>("Radzen.closeDialog");
-        }
-
-        await InvokeAsync(() => 
-        { 
-            StateHasChanged(); 
-        });
-    }
-
-    public void Dispose()
-    {
-        Service.OnOpen -= OnOpen;
-        Service.OnClose -= OnClose;
-
-        Service.OnSideOpen -= OnSideOpen;
-        Service.OnSideClose -= OnSideClose;
-    }
-
-    protected override void OnInitialized()
-    {
-        Service.OnOpen += OnOpen;
-        Service.OnClose += OnClose;
-
-        Service.OnSideOpen += OnSideOpen;
-        Service.OnSideClose += OnSideClose;
-    }
-
-    void OnSideOpen(Type sideComponent, Dictionary<string, object> parameters, SideDialogOptions options)
-    {
-        sideDialogOptions = options;
-        
-        // Create a DialogOptions from SideDialogOptions by copying common properties
-        var dialogOptions = new DialogOptions()
-        {
-            ShowTitle = options.ShowTitle,
-            ShowClose = options.ShowClose,
-            Width = options.Width,
-            Height = options.Height,
-            Style = options.Style,
-            CloseDialogOnOverlayClick = options.CloseDialogOnOverlayClick,
-            CssClass = options.CssClass,
-            WrapperCssClass = options.WrapperCssClass,
-            ContentCssClass = options.ContentCssClass,
-            CloseTabIndex = options.CloseTabIndex,
-            TitleContent = options.TitleContent
-        };
-        
-        // Create a Dialog object for the side dialog to support cascading parameter
-        sideDialog = new Dialog() 
-        { 
-            Title = options.Title, 
-            Type = sideComponent, 
-            Parameters = parameters, 
-            Options = dialogOptions 
-        };
-        
-        // Wrap the content in a CascadingValue to provide the Dialog object to child components
-        sideDialogContent = new RenderFragment(builder =>
-        {
-            // Open CascadingValue
-            builder.OpenComponent<CascadingValue<Dialog>>(0);
-            builder.AddAttribute(1, "Value", sideDialog);
-            builder.AddAttribute(2, "IsFixed", true);
-            builder.AddAttribute(3, "ChildContent", (RenderFragment)((builder2) =>
-            {
-                // Open the actual component
-                builder2.OpenComponent(0, sideComponent);
-                foreach (var parameter in parameters)
-                {
-                    builder2.AddAttribute(1, parameter.Key, parameter.Value);
-                }
-                builder2.CloseComponent();
-            }));
-            builder.CloseComponent(); // Close CascadingValue
-        });
-        isSideDialogOpen = true;
-        StateHasChanged();
-    }
-
-    bool sideDialogClosing = false;
-
-    async Task OnSideCloseAsync()
-    {
-        sideDialogClosing = true;
-
-        StateHasChanged();
-
-        await Task.Delay(300);
-
-        isSideDialogOpen = false;
-        sideDialogClosing = false;
-
-        StateHasChanged();
-
-        Service.OnSideCloseComplete();
-    }
-
-    void OnSideClose(dynamic _)
-    {
-        if (isSideDialogOpen)
-        {
-            InvokeAsync(OnSideCloseAsync);
-        }
-    }
-
-    void OnOpen(string title, Type type, Dictionary<string, object> parameters, DialogOptions options)
-    {
-        Open(title, type, parameters, options).ConfigureAwait(false);
-    }
-
-    void OnClose(dynamic result)
-    {
-        Close(result).ConfigureAwait(false);
-    }
-
-    string GetSideDialogCssClass() => ClassList.Create("rz-dialog-side")
-                                               .Add($"rz-dialog-side-position-{sideDialogOptions.Position.ToString().ToLower()}")
-                                               .Add(sideDialogOptions.CssClass)
-                                               .Add("rz-open", !sideDialogClosing)
-                                               .Add("rz-close", sideDialogClosing)
-                                               .ToString();
-
-    string GetSideDialogStyle()
-    {
-        string widthStyle = string.IsNullOrEmpty(sideDialogOptions.Width) ? string.Empty : $"width: {sideDialogOptions.Width};";
-        string heightStyle = string.IsNullOrEmpty(sideDialogOptions.Height) ? string.Empty : $"height: {sideDialogOptions.Height};";
-
-        return $"{widthStyle}{heightStyle}{sideDialogOptions.Style}";
-    }
-
-    protected override async Task OnAfterRenderAsync(bool firstRender)
-    {
-        await base.OnAfterRenderAsync(firstRender);
-
-        if (isSideDialogOpen)
-        {
-            await JSRuntime.InvokeAsync<string>("Radzen.openSideDialog", sideDialogOptions);
-        }
-    }
-}
diff --git a/Radzen.Blazor/RadzenDialog.razor.cs b/Radzen.Blazor/RadzenDialog.razor.cs
new file mode 100644
index 00000000000..1eaa725a288
--- /dev/null
+++ b/Radzen.Blazor/RadzenDialog.razor.cs
@@ -0,0 +1,256 @@
+using Microsoft.AspNetCore.Components;
+using Microsoft.JSInterop;
+using Radzen.Blazor.Rendering;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace Radzen.Blazor;
+
+#nullable enable
+
+/// <summary>
+/// Represents a dialog component in the Radzen framework.
+/// RadzenDialog is a reusable component that facilitates the creation of modal dialogs.
+/// It can be used to display custom content, collect user input or confirm/cancel operations.
+/// </summary>
+public partial class RadzenDialog
+{
+    private string SideDialogContentCssClass
+    {
+        get
+        {
+            var baseCss = "rz-dialog-side-content";
+            return string.IsNullOrEmpty(sideDialogOptions?.ContentCssClass)
+                ? baseCss
+                : $"{baseCss} {sideDialogOptions.ContentCssClass}";
+        }
+    }
+
+    [Inject] private DialogService? Service { get; set; }
+
+    /// <summary>
+    /// Gets or sets the close side dialog aria label text.
+    /// </summary>
+    /// <value>The close side dialog aria label text.</value>
+    [Parameter]
+    public string CloseSideDialogAriaLabel { get; set; } = "Close side dialog";
+
+    private List<Dialog> dialogs = new List<Dialog>();
+    private bool isSideDialogOpen;
+    private RenderFragment? sideDialogContent;
+    private SideDialogOptions? sideDialogOptions;
+    private Dialog? sideDialog;
+    private ElementReference? resizeBarElement;
+    private ElementReference? sideDialogElement;
+    private IJSObjectReference? sideDialogResizeHandleJsModule;
+
+    /// <summary>
+    /// Opens a new dialog with specified parameters and options.
+    /// </summary>
+    /// <param name="title">The title of the dialog.</param>
+    /// <param name="type">The content type of the dialog, usually a component type.</param>
+    /// <param name="parameters">A dictionary of parameters to pass to the dialog content.</param>
+    /// <param name="options">Additional configuration options for the dialog, such as size or behavior.</param>
+    /// <returns>A Task that represents the asynchronous operation of opening the dialog.</returns>
+    public async Task Open(string title,
+        Type type,
+        Dictionary<string, object> parameters,
+        DialogOptions options)
+    {
+        dialogs.Add(new Dialog() { Title = title, Type = type, Parameters = parameters, Options = options });
+
+        await InvokeAsync(() => { StateHasChanged(); });
+    }
+
+    /// <summary>
+    /// Closes the currently open dialog and returns the specified result.
+    /// </summary>
+    /// <param name="result">The result to return when the dialog is closed. This can contain any data that needs to be passed back to the caller.</param>
+    /// <returns>A Task that represents the asynchronous operation of closing the dialog.</returns>
+    public async Task Close(dynamic result)
+    {
+        var lastDialog = dialogs.LastOrDefault();
+        if (lastDialog != null)
+        {
+            dialogs.Remove(lastDialog);
+            if (dialogs.Count == 0) await JSRuntime.InvokeAsync<string>("Radzen.closeDialog");
+        }
+
+        await InvokeAsync(() =>
+        {
+            StateHasChanged();
+        });
+    }
+
+    /// <inheritdoc />
+    public void Dispose()
+    {
+        if (Service is null) return;
+        Service.OnOpen -= OnOpen;
+        Service.OnClose -= OnClose;
+        Service.OnSideOpen -= OnSideOpen;
+        Service.OnSideClose -= OnSideClose;
+    }
+
+    /// <inheritdoc />
+    protected override void OnInitialized()
+    {
+        if (Service is null) return;
+        Service.OnOpen += OnOpen;
+        Service.OnClose += OnClose;
+        Service.OnSideOpen += OnSideOpen;
+        Service.OnSideClose += OnSideClose;
+    }
+
+    private void OnSideOpen(Type sideComponent, Dictionary<string, object> parameters, SideDialogOptions options)
+    {
+        sideDialogOptions = options;
+
+        // Create a DialogOptions from SideDialogOptions by copying common properties
+        var dialogOptions = new DialogOptions()
+        {
+            ShowTitle = options.ShowTitle,
+            ShowClose = options.ShowClose,
+            Width = options.Width,
+            Height = options.Height,
+            Style = options.Style,
+            CloseDialogOnOverlayClick = options.CloseDialogOnOverlayClick,
+            CssClass = options.CssClass,
+            WrapperCssClass = options.WrapperCssClass,
+            ContentCssClass = options.ContentCssClass,
+            CloseTabIndex = options.CloseTabIndex,
+            TitleContent = options.TitleContent
+        };
+
+        // Create a Dialog object for the side dialog to support cascading parameter
+        sideDialog = new Dialog()
+        {
+            Title = options.Title, Type = sideComponent, Parameters = parameters, Options = dialogOptions
+        };
+
+        // Wrap the content in a CascadingValue to provide the Dialog object to child components
+        sideDialogContent = new RenderFragment(builder =>
+        {
+            // Open CascadingValue
+            builder.OpenComponent<CascadingValue<Dialog>>(0);
+            builder.AddAttribute(1, "Value", sideDialog);
+            builder.AddAttribute(2, "IsFixed", true);
+            builder.AddAttribute(3, "ChildContent", (RenderFragment)((builder2) =>
+            {
+                // Open the actual component
+                builder2.OpenComponent(0, sideComponent);
+                foreach (var parameter in parameters)
+                {
+                    builder2.AddAttribute(1, parameter.Key, parameter.Value);
+                }
+
+                builder2.CloseComponent();
+            }));
+            builder.CloseComponent(); // Close CascadingValue
+        });
+        isSideDialogOpen = true;
+        StateHasChanged();
+    }
+
+    private bool sideDialogClosing = false;
+
+    private async Task OnSideCloseAsync()
+    {
+        sideDialogClosing = true;
+
+        StateHasChanged();
+
+        await Task.Delay(300);
+
+        isSideDialogOpen = false;
+        sideDialogClosing = false;
+
+        StateHasChanged();
+
+        Service?.OnSideCloseComplete();
+    }
+
+    private void OnSideClose(dynamic _)
+    {
+        if (isSideDialogOpen)
+        {
+            InvokeAsync(OnSideCloseAsync);
+        }
+    }
+
+    private void OnOpen(string title,
+        Type type,
+        Dictionary<string, object> parameters,
+        DialogOptions options)
+    {
+        Open(title, type, parameters, options).ConfigureAwait(false);
+    }
+
+    private void OnClose(dynamic result)
+    {
+        Close(result).ConfigureAwait(false);
+    }
+
+    private string GetSideDialogCssClass() => ClassList.Create("rz-dialog-side")
+        .Add($"rz-dialog-side-position-{sideDialogOptions?.Position.ToString().ToLower()}")
+        .Add(sideDialogOptions?.CssClass)
+        .Add("rz-open", !sideDialogClosing)
+        .Add("rz-close", sideDialogClosing)
+        .ToString();
+
+    private string GetResizeBarCssClass() => ClassList.Create("rz-dialog-resize-bar")
+        .ToString();
+
+    private string GetSideDialogStyle()
+    {
+        string widthStyle = string.IsNullOrEmpty(sideDialogOptions?.Width)
+            ? string.Empty
+            : $"width: {sideDialogOptions.Width};";
+        string heightStyle = string.IsNullOrEmpty(sideDialogOptions?.Height)
+            ? string.Empty
+            : $"height: {sideDialogOptions.Height};";
+
+        return $"{widthStyle}{heightStyle}{sideDialogOptions?.Style}";
+    }
+
+    /// <inheritdoc />
+    protected override async Task OnAfterRenderAsync(bool firstRender)
+    {
+        await base.OnAfterRenderAsync(firstRender);
+
+        if (isSideDialogOpen)
+        {
+            await JSRuntime.InvokeAsync<string>("Radzen.openSideDialog", sideDialogOptions);
+
+            if (sideDialogOptions is { Resizable: true } && resizeBarElement.HasValue)
+            {
+                sideDialogResizeHandleJsModule =
+                    await JSRuntime.InvokeAsync<IJSObjectReference>("Radzen.initSideDialogResize",
+                        resizeBarElement, sideDialogElement);
+            }
+        }
+    }
+
+    /// <summary>
+    /// Disposes resources used by the dialog asynchronously.
+    /// This method is typically called to clean up unmanaged resources or
+    /// perform cleanup tasks for JavaScript interop involved in the dialog component.
+    /// </summary>
+    /// <returns>A ValueTask that represents the asynchronous disposal operation.</returns>
+    public async ValueTask DisposeAsync()
+    {
+        try
+        {
+            if (sideDialogResizeHandleJsModule != null)
+            {
+                await sideDialogResizeHandleJsModule.InvokeVoidAsync("dispose");
+            }
+        }
+        catch
+        {
+            /* Ignore */
+        }
+    }
+}
\ No newline at end of file
diff --git a/Radzen.Blazor/themes/components/blazor/_dialog.scss b/Radzen.Blazor/themes/components/blazor/_dialog.scss
index 1a514461e2d..6d1ea9cecd6 100644
--- a/Radzen.Blazor/themes/components/blazor/_dialog.scss
+++ b/Radzen.Blazor/themes/components/blazor/_dialog.scss
@@ -19,6 +19,12 @@ $dialog-border-radius: var(--rz-border-radius) !default;
 $dialog-mask-zindex: 1000 !default;
 $dialog-zindex: 1001 !default;
 $dialog-transition: .1s ease-in-out !default;
+$dialog-side-resize-bar-color: var(--rz-splitter-bar-color);
+$dialog-side-resize-bar-background-color: var(--rz-splitter-bar-background-color);
+$dialog-side-resize-bar-hover-opacity: var(--rz-splitter-bar-hover-opacity);
+$dialog-side-resize-bar-thickness: 8px;
+$dialog-side-resize-bar-length: 100%;
+$dialog-side-resize-bar-handle-size: 16px;
 
 .rz-dialog-wrapper {
   box-sizing: border-box;
@@ -56,6 +62,80 @@ $dialog-transition: .1s ease-in-out !default;
   box-shadow: var(--rz-dialog-shadow);
   border-radius: var(--rz-dialog-border-radius);
   overflow-y: auto;
+
+  > .rz-dialog-resize-bar {
+    flex: 0 0 auto;
+    position: absolute;
+    text-align: center;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    color: $dialog-side-resize-bar-color;
+    background-color: $dialog-side-resize-bar-background-color;
+    opacity: 0.4;
+    user-select: none;
+
+    > .rz-resize {
+      pointer-events: none;
+      border: 1px solid $dialog-side-resize-bar-color;
+      border-radius: 1px;
+    }
+
+    &:hover {
+      background-color: $dialog-side-resize-bar-background-color;
+      opacity: $dialog-side-resize-bar-hover-opacity;
+    }
+  }
+
+  &-position-right,
+  &-position-left {
+    flex-direction: row;
+
+    > .rz-dialog-resize-bar {
+      width: $dialog-side-resize-bar-thickness;
+      height: $dialog-side-resize-bar-length;
+      cursor: col-resize;
+      flex-direction: column;
+
+      > .rz-resize {
+        height: $dialog-side-resize-bar-handle-size;
+        margin: 2px 0;
+      }
+    }
+  }
+
+  &-position-top,
+  &-position-bottom {
+    flex-direction: column;
+
+    > .rz-dialog-resize-bar {
+      width: $dialog-side-resize-bar-length;
+      height: $dialog-side-resize-bar-thickness;
+      cursor: row-resize;
+      flex-direction: row;
+
+      > .rz-resize {
+        width: $dialog-side-resize-bar-handle-size;
+        margin: 0 2px;
+      }
+    }
+  }
+
+  &-position-right > .rz-dialog-resize-bar {
+      left: 0;
+  }
+
+  &-position-left > .rz-dialog-resize-bar {
+      right: 0;
+  }
+
+  &-position-bottom > .rz-dialog-resize-bar {
+      top: 0;
+  }
+
+  &-position-top > .rz-dialog-resize-bar {
+      bottom: 0;
+  }
 }
 
 .rz-dialog-titlebar,
diff --git a/Radzen.Blazor/wwwroot/Radzen.Blazor.js b/Radzen.Blazor/wwwroot/Radzen.Blazor.js
index 127435245c2..3f6d4aa4f57 100644
--- a/Radzen.Blazor/wwwroot/Radzen.Blazor.js
+++ b/Radzen.Blazor/wwwroot/Radzen.Blazor.js
@@ -1449,6 +1449,89 @@ window.Radzen = {
           }
       }, 500);
   },
+  initSideDialogResize: function(handle, sideDialog){
+        const dir = (handle.dataset.dir || 'right').toLowerCase();
+        const cs = window.getComputedStyle(sideDialog);
+        const parent = sideDialog.parentNode;
+        const parentIsFlex = parent && getComputedStyle(parent).display.includes('flex');
+        const toPixels = (v, axis) => {
+            if (!v || v === 'none') return NaN;
+            if (v.endsWith && v.endsWith('px')) return parseFloat(v);
+            if (v.endsWith && v.endsWith('%')) {
+                const base = axis === 'y' ? window.innerHeight : window.innerWidth;
+                const p = parseFloat(v);
+                return Number.isFinite(p) ? (base * p / 100) : NaN;
+            }
+            const n = parseFloat(v);
+            return Number.isFinite(n) ? n : NaN;
+        };
+
+        let MIN_W = toPixels(cs.minWidth, 'x') || 300;
+        let MAX_W = toPixels(cs.maxWidth, 'x') || Infinity;
+        let MIN_H = toPixels(cs.minHeight, 'y') || 200;
+        let MAX_H = toPixels(cs.maxHeight, 'y') || Infinity;
+
+        // Guard against invalid ranges caused by percentage max being smaller than min
+        if (Number.isFinite(MIN_W) && Number.isFinite(MAX_W) && MAX_W < MIN_W) MAX_W = Infinity;
+        if (Number.isFinite(MIN_H) && Number.isFinite(MAX_H) && MAX_H < MIN_H) MAX_H = Infinity;
+
+        let start = null;
+
+        const onDown = (e) => {
+            e.preventDefault();
+            handle.setPointerCapture?.(e.pointerId);
+
+            const rect = sideDialog.getBoundingClientRect();
+            start = { x: e.clientX, y: e.clientY, w: rect.width, h: rect.height };
+
+            document.addEventListener('pointermove', onMove);
+            document.addEventListener('pointerup', onUp, { once: true });
+            document.body.classList.add('dragging');
+        };
+
+        const clamp = (v, min, max) => Math.max(min, Math.min(max, v));
+
+        const applyWidth = (w) => {
+            if (parentIsFlex)
+                sideDialog.style.flexBasis = Math.round(w) + 'px';
+            else
+                sideDialog.style.width = Math.round(w) + 'px';
+        };
+        const applyHeight = (h) => {
+            sideDialog.style.height = `${Math.round(h)}px`;
+        };
+
+        const onMove = (e) => {
+            if (!start) return;
+
+            const dx = e.clientX - start.x;
+            const dy = e.clientY - start.y;
+
+            switch (dir) {
+                case 'right': applyWidth(clamp(start.w - dx, MIN_W, MAX_W)); break;
+                case 'left': applyWidth(clamp(start.w + dx, MIN_W, MAX_W)); break;
+                case 'bottom': applyHeight(clamp(start.h - dy, MIN_H, MAX_H)); break;
+                case 'top': applyHeight(clamp(start.h + dy, MIN_H, MAX_H)); break;
+            }
+        };
+
+        const onUp = (e) => {
+            handle.releasePointerCapture?.(e.pointerId);
+            start = null;
+            document.removeEventListener('pointermove', onMove);
+            document.body.classList.remove('dragging');
+        };
+
+        handle.addEventListener('pointerdown', onDown);
+
+        return {
+            dispose() {
+                handle.removeEventListener('pointerdown', onDown);
+                document.removeEventListener('pointermove', onMove);
+                document.body.classList.remove('dragging');
+            }
+        };
+  },
   openDialog: function (options, dialogService, dialog) {
     if (Radzen.closeAllPopups) {
         Radzen.closeAllPopups();
diff --git a/RadzenBlazorDemos/Pages/DialogSide.razor b/RadzenBlazorDemos/Pages/DialogSide.razor
index e02dc78d010..a54faebccf0 100644
--- a/RadzenBlazorDemos/Pages/DialogSide.razor
+++ b/RadzenBlazorDemos/Pages/DialogSide.razor
@@ -15,6 +15,10 @@
             <RadzenLabel Text="Close on overlay click:" Component="Close" />
             <RadzenSwitch @bind-Value="@closeDialogOnOverlayClick" Disabled=@(!showMask) Name="Close" />
         </RadzenStack>
+        <RadzenStack Orientation="Orientation.Horizontal" Gap="0.5rem" AlignItems="AlignItems.Center">
+            <RadzenLabel Text="Resizable:" Component="Resizable" />
+            <RadzenSwitch @bind-Value="@resizable" Name="Resizable" />
+        </RadzenStack>
     </RadzenStack>
     <RadzenButton Text="Dialog on Side" ButtonStyle="ButtonStyle.Secondary" Click="@OpenSideDialog" />
 </div>
@@ -23,9 +27,10 @@
     DialogPosition position;
     bool closeDialogOnOverlayClick;
     bool showMask;
+    bool resizable;
 
     async Task OpenSideDialog()
     {
-        await DialogService.OpenSideAsync<DialogSideContent>("Side Panel", options: new SideDialogOptions { CloseDialogOnOverlayClick = closeDialogOnOverlayClick, Position = position, ShowMask = showMask });
+        await DialogService.OpenSideAsync<DialogSideContent>("Side Panel", options: new SideDialogOptions { CloseDialogOnOverlayClick = closeDialogOnOverlayClick, Resizable = resizable, Position = position, ShowMask = showMask });
     }
 }
\ No newline at end of file