diff --git a/wpf/Magnifier/Advance-features.md b/wpf/Magnifier/Advance-features.md
new file mode 100644
index 0000000000..659ebb8c8c
--- /dev/null
+++ b/wpf/Magnifier/Advance-features.md
@@ -0,0 +1,324 @@
+---
+layout: post
+title: Zoom Control in WPF Magnifier | Syncfusion®
+description: Learn how to control zoom levels programmatically using ZoomIn, ZoomOut methods and ZoomFactor property in the WPF Magnifier control.
+platform: wpf
+control: Magnifier
+documentation: ug
+---
+# Zooming feature of Magnifier
+
+The Magnifier control provides flexible zooming through the [`ZoomFactor`](https://help.syncfusion.com/cr/wpf/Syncfusion.Windows.Shared.Magnifier.html#Syncfusion_Windows_Shared_Magnifier_ZoomFactor) property and programmatic methods. You can configure zoom levels declaratively or adjust them dynamically at runtime.
+
+## ZoomFactor Property
+
+The `ZoomFactor` property determines the relative size of the area displayed inside the magnifier frame. It controls the magnification level and accepts values between `0.0` and `1.0`.
+
+### Understanding ZoomFactor Values
+
+* **Lower values** (e.g., `0.2`) = **Higher magnification** (smaller area shown, more zoomed in)
+* **Higher values** (e.g., `0.8`) = **Lower magnification** (larger area shown, less zoomed in)
+* **Value of `1.0`** = **No magnification** (content shown at original size)
+
+The ZoomFactor property is automatically coerced to the valid range:
+* Values greater than `1.0` are set to `1.0`
+* Values less than `0.0` are set to `0.0`
+
+### Setting ZoomFactor Declaratively
+
+**XAML:**
+
+```xml
+
+
+
+```
+
+**C#:**
+
+```csharp
+var magnifier = new Magnifier
+{
+ ZoomFactor = 0.3,
+ FrameType = FrameType.Circle,
+ FrameRadius = 120
+};
+```
+
+## Programmatic Zoom Control
+
+The Magnifier control provides [`ZoomIn()`](https://help.syncfusion.com/cr/wpf/Syncfusion.Windows.Shared.Magnifier.html#Syncfusion_Windows_Shared_Magnifier_ZoomIn_System_Double_) and [`ZoomOut()`](https://help.syncfusion.com/cr/wpf/Syncfusion.Windows.Shared.Magnifier.html#Syncfusion_Windows_Shared_Magnifier_ZoomOut_System_Double_) methods to adjust zoom levels dynamically at runtime.
+
+### ZoomIn Method
+
+The `ZoomIn(double zoomFactor)` method increases magnification by dividing the current `ZoomFactor` by the specified factor.
+
+**Signature:**
+```csharp
+public void ZoomIn(double zoomFactor)
+```
+
+**Example:**
+```csharp
+// Current ZoomFactor = 0.4
+magnifier.ZoomIn(2.0);
+// New ZoomFactor = 0.4 / 2.0 = 0.2 (higher magnification)
+```
+
+### ZoomOut Method
+
+The `ZoomOut(double zoomFactor)` method decreases magnification by multiplying the current `ZoomFactor` by the specified factor.
+
+**Signature:**
+```csharp
+public void ZoomOut(double zoomFactor)
+```
+
+**Example:**
+```csharp
+// Current ZoomFactor = 0.2
+magnifier.ZoomOut(2.0);
+// New ZoomFactor = 0.2 * 2.0 = 0.4 (lower magnification)
+```
+
+## Implementing Zoom Controls
+
+### Zoom Buttons Example
+
+Add zoom in/out buttons to your application for user-controlled magnification.
+
+**XAML:**
+
+```xml
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+```
+
+**C#:**
+
+```csharp
+using System;
+using System.Windows;
+using Syncfusion.Windows.Shared;
+
+public partial class MainWindow : Window
+{
+ public MainWindow()
+ {
+ InitializeComponent();
+
+ // Attach magnifier to content grid
+ Magnifier.SetCurrent(ContentGrid, MagnifierControl);
+
+ // Update zoom level display
+ UpdateZoomLevelDisplay();
+
+ // Subscribe to ZoomFactor changes
+ MagnifierControl.ZoomFactorChanged += (s, e) => UpdateZoomLevelDisplay();
+ }
+
+ private void ZoomIn_Click(object sender, RoutedEventArgs e)
+ {
+ // Zoom in by factor of 1.5
+ MagnifierControl.ZoomIn(1.5);
+ }
+
+ private void ZoomOut_Click(object sender, RoutedEventArgs e)
+ {
+ // Zoom out by factor of 1.5
+ MagnifierControl.ZoomOut(1.5);
+ }
+
+ private void ResetZoom_Click(object sender, RoutedEventArgs e)
+ {
+ // Reset to default zoom
+ MagnifierControl.ZoomFactor = 0.5;
+ }
+
+ private void UpdateZoomLevelDisplay()
+ {
+ double magnification = 1.0 / MagnifierControl.ZoomFactor;
+ ZoomLevelText.Text = $"{magnification:F1}x (ZoomFactor: {MagnifierControl.ZoomFactor:F2})";
+ }
+}
+```
+
+### Keyboard Zoom Control
+
+Implement keyboard shortcuts for zoom control:
+
+```csharp
+private void Window_PreviewKeyDown(object sender, KeyEventArgs e)
+{
+ // Ctrl + Plus = Zoom In
+ if (Keyboard.Modifiers == ModifierKeys.Control && e.Key == Key.OemPlus)
+ {
+ e.Handled = true;
+ MagnifierControl.ZoomIn(1.2);
+ }
+ // Ctrl + Minus = Zoom Out
+ else if (Keyboard.Modifiers == ModifierKeys.Control && e.Key == Key.OemMinus)
+ {
+ e.Handled = true;
+ MagnifierControl.ZoomOut(1.2);
+ }
+ // Ctrl + 0 = Reset Zoom
+ else if (Keyboard.Modifiers == ModifierKeys.Control && e.Key == Key.D0)
+ {
+ e.Handled = true;
+ MagnifierControl.ZoomFactor = 0.5;
+ }
+}
+```
+
+### Mouse Wheel Zoom Control
+
+Implement mouse wheel zoom:
+
+```csharp
+private void ContentGrid_MouseWheel(object sender, MouseWheelEventArgs e)
+{
+ if (Keyboard.Modifiers == ModifierKeys.Control)
+ {
+ e.Handled = true;
+
+ if (e.Delta > 0)
+ {
+ // Scroll up = Zoom In
+ MagnifierControl.ZoomIn(1.1);
+ }
+ else
+ {
+ // Scroll down = Zoom Out
+ MagnifierControl.ZoomOut(1.1);
+ }
+ }
+}
+```
+
+## Dynamic Zoom Scenarios
+
+### Zoom Level Presets
+
+Provide preset zoom levels for common use cases:
+
+```csharp
+public enum ZoomPreset
+{
+ Low, // 0.6
+ Medium, // 0.4
+ High, // 0.25
+ VeryHigh // 0.15
+}
+
+public void SetZoomPreset(ZoomPreset preset)
+{
+ MagnifierControl.ZoomFactor = preset switch
+ {
+ ZoomPreset.Low => 0.6,
+ ZoomPreset.Medium => 0.4,
+ ZoomPreset.High => 0.25,
+ ZoomPreset.VeryHigh => 0.15,
+ _ => 0.5
+ };
+}
+```
+
+### Context-Sensitive Zoom
+
+Adjust zoom based on content type:
+
+```csharp
+private void SetZoomForContent(string contentType)
+{
+ switch (contentType)
+ {
+ case "Text":
+ MagnifierControl.ZoomFactor = 0.4; // Moderate zoom for text
+ break;
+ case "Image":
+ MagnifierControl.ZoomFactor = 0.25; // Higher zoom for images
+ break;
+ case "Chart":
+ MagnifierControl.ZoomFactor = 0.5; // Lower zoom for charts
+ break;
+ }
+}
+```
+### **Zooming demo**
+
+
+
+
+## ZoomFactor and Magnification Relationship
+
+Understanding the inverse relationship:
+
+| ZoomFactor | Magnification | Best For |
+|------------|---------------|----------|
+| 0.8 - 1.0 | 1x - 1.25x | Slight enhancement |
+| 0.5 - 0.7 | 1.4x - 2x | General inspection |
+| 0.3 - 0.4 | 2.5x - 3.3x | Detailed viewing |
+| 0.15 - 0.25 | 4x - 6.7x | Fine detail analysis |
+| < 0.15 | > 7x | Pixel-level inspection |
+
+## Best Practices
+
+* **Incremental adjustments**: Use zoom factors between 1.1 and 2.0 for smooth, user-friendly zoom changes.
+* **Zoom limits**: Consider implementing minimum and maximum zoom levels to prevent unusable magnification states.
+* **Visual feedback**: Display the current zoom level to help users understand the magnification amount.
+* **Smooth transitions**: For frequent zoom changes, consider adding animation or throttling to improve user experience.
+* **Context awareness**: Adjust default zoom levels based on content type (text, images, diagrams) for optimal viewing.
+
+
diff --git a/wpf/Magnifier/Exporting-Feature.md b/wpf/Magnifier/Exporting-Feature.md
new file mode 100644
index 0000000000..84037c50ce
--- /dev/null
+++ b/wpf/Magnifier/Exporting-Feature.md
@@ -0,0 +1,203 @@
+---
+layout: post
+title: Exporting Magnified Content in WPF Magnifier | Syncfusion®
+description: Learn how to export and save magnified content using various export methods in the WPF Magnifier control.
+platform: wpf
+control: Magnifier
+documentation: ug
+---
+
+# Exporting Magnified Content
+
+The Magnifier control provides the ability to export the currently magnified content to various image formats or copy it to the system clipboard. This feature is useful when you need to capture and save the zoomed view for documentation, sharing, or further analysis.
+
+## Export Methods
+
+The Magnifier control provides the following methods for exporting magnified content:
+
+| Method | Description |
+|--------|-------------|
+| [`CopyToClipboard()`](https://help.syncfusion.com/cr/wpf/Syncfusion.Windows.Shared.Magnifier.html#Syncfusion_Windows_Shared_Magnifier_CopyToClipboard) | Copies the magnified content to the system clipboard as an image. Users can then paste it into other applications. |
+| [`Save(Stream)`](https://help.syncfusion.com/cr/wpf/Syncfusion.Windows.Shared.Magnifier.html#Syncfusion_Windows_Shared_Magnifier_Save_System_IO_Stream_) | Saves the magnified content to a stream using the default BMP encoder. |
+| [`Save(Stream, BitmapEncoder)`](https://help.syncfusion.com/cr/wpf/Syncfusion.Windows.Shared.Magnifier.html#Syncfusion_Windows_Shared_Magnifier_Save_System_IO_Stream_System_Windows_Media_Imaging_BitmapEncoder_) | Saves the magnified content to a stream with a specified bitmap encoder (PNG, JPEG, GIF, etc.). |
+| [`Save(string)`](https://help.syncfusion.com/cr/wpf/Syncfusion.Windows.Shared.Magnifier.html#Syncfusion_Windows_Shared_Magnifier_Save_System_String_) | Saves the magnified content to a file. The encoder is automatically determined by the file extension. |
+| [`Save(string, BitmapEncoder)`](https://help.syncfusion.com/cr/wpf/Syncfusion.Windows.Shared.Magnifier.html#Syncfusion_Windows_Shared_Magnifier_Save_System_String_System_Windows_Media_Imaging_BitmapEncoder_) | Saves the magnified content to a file with a specified bitmap encoder. |
+| [`SaveToXps(Stream)`](https://help.syncfusion.com/cr/wpf/Syncfusion.Windows.Shared.Magnifier.html#Syncfusion_Windows_Shared_Magnifier_SaveToXps_System_IO_Stream_) | Saves the magnified content to a stream in XPS format. |
+| [`SaveToXps(string)`](https://help.syncfusion.com/cr/wpf/Syncfusion.Windows.Shared.Magnifier.html#Syncfusion_Windows_Shared_Magnifier_SaveToXps_System_String_) | Saves the magnified content to an XPS file. |
+
+## How to Export Magnified Content
+
+The example provided below demonstrates one way to trigger export operations (not the only way). You can call export methods in any event handler or mechanism that fires while the magnifier is in an active state. The magnifier is active when the mouse is over the target element and the magnified frame is visible.
+
+The following example uses the `PreviewKeyDown` event on the Window to call different export methods based on keyboard shortcuts. This approach allows users to quickly export content while the magnifier is active without losing focus.
+
+### XAML
+
+```xml
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+```
+
+### C#
+
+```csharp
+using System;
+using System.IO;
+using System.Windows;
+using System.Windows.Input;
+using System.Windows.Media.Imaging;
+using Syncfusion.Windows.Shared;
+
+public partial class MainWindow : Window
+{
+ public MainWindow()
+ {
+ InitializeComponent();
+
+ // Attach the magnifier to the root grid
+ Magnifier.SetCurrent(RootGrid, MagnifierControl);
+ }
+
+ private void Window_PreviewKeyDown(object sender, KeyEventArgs e)
+ {
+ // Ensure export is enabled
+ if (!MagnifierControl.EnableExport)
+ return;
+
+ // Check for Ctrl + Shift modifier keys
+ if (Keyboard.Modifiers != (ModifierKeys.Control | ModifierKeys.Shift))
+ return;
+
+ try
+ {
+ // Ctrl + Shift + C → Copy to Clipboard
+ if (e.Key == Key.C)
+ {
+ e.Handled = true;
+ MagnifierControl.CopyToClipboard();
+ }
+ // Ctrl + Shift + S → Save to stream (BMP format)
+ else if (e.Key == Key.S)
+ {
+ e.Handled = true;
+ using var stream = File.Create("Magnifier_Export.bmp");
+ MagnifierControl.Save(stream);
+ }
+ // Ctrl + Shift + P → Save to stream with PNG encoder
+ else if (e.Key == Key.P)
+ {
+ e.Handled = true;
+ using var stream = File.Create("Magnifier_Export.png");
+ MagnifierControl.Save(stream, new PngBitmapEncoder());
+ }
+ // Ctrl + Shift + F → Save by filename
+ else if (e.Key == Key.F)
+ {
+ e.Handled = true;
+ MagnifierControl.Save("Magnifier_Export.png");
+ }
+ // Ctrl + Shift + E → Save by filename with encoder
+ else if (e.Key == Key.E)
+ {
+ e.Handled = true;
+ MagnifierControl.Save("Magnifier_Export.jpg", new JpegBitmapEncoder());
+ }
+ // Ctrl + Shift + X → Save to XPS stream
+ else if (e.Key == Key.X)
+ {
+ e.Handled = true;
+ using var stream = File.Create("Magnifier_Export.xps");
+ MagnifierControl.SaveToXps(stream);
+ }
+ // Ctrl + Shift + Z → Save to XPS file
+ else if (e.Key == Key.Z)
+ {
+ e.Handled = true;
+ MagnifierControl.SaveToXps("Magnifier_Export.xps");
+ }
+ }
+ catch (Exception ex)
+ {
+ MessageBox.Show($"Export failed: {ex.Message}");
+ }
+ }
+}
+```
+
+**In this example:**
+* The `PreviewKeyDown` event handler checks if `EnableExport` is `true` before attempting any export operation.
+* Different keyboard shortcuts trigger different export methods.
+* Files are saved directly without opening a dialog to keep the magnifier active during export.
+
+## Important Notes and Limitations
+
+### Export Behavior
+
+* **Only magnified content is exported**: The export captures only what is currently visible inside the magnifier frame, not the entire target element.
+* **Magnifier must be active**: The magnifier must be in an active state (visible and positioned over the target element) to properly export the magnified content.
+* **Inactive magnifier exports**: If the mouse leaves the target element, the magnifier hides. Attempting to export while the magnifier is hidden will only capture the frame background or the configured magnifier properties, not the actual content.
+
+**Sample View**
+
+
+
+**Exported images**
+
+
+
+### EnableExport Property
+
+All export methods depend on the [`EnableExport`](https://help.syncfusion.com/cr/wpf/Syncfusion.Windows.Shared.Magnifier.html#Syncfusion_Windows_Shared_Magnifier_EnableExport) property being set to *`true`*. If `EnableExport` is *`false`*, export operations will not execute. By default `EnableExport` is *`true`*.
+
+### File Format Support
+
+When using `Save(string)`, the file extension determines the encoder:
+* `.bmp` → BMP format
+* `.png` → PNG format
+* `.jpg` or `.jpeg` → JPEG format
+* `.gif` → GIF format
+* `.tif` or `.tiff` → TIFF format
+* `.wdp` → WMP format
+
+**XPS Format Note**: XPS format files are not natively supported in Windows 10 and Windows 11. However, XPS files can be viewed using online XPS viewer tools or by installing XPS Viewer in Windows.
+
+### Maintaining Active State During Export
+
+If you open a file dialog or any UI element that causes focus loss, the magnifier may become inactive (hidden). To maintain the magnifier's active state during export:
+* Use simple filenames without specifying full paths. This saves files to the application's output directory without requiring user interaction, keeping the magnifier focused and active.
+* Avoid showing modal dialogs that require user interaction while exporting.
+* Use background operations or asynchronous methods if additional processing is needed.
+
+This ensures the magnifier remains visible and the exported content accurately reflects the magnified view.
diff --git a/wpf/Magnifier/Getting-Started.md b/wpf/Magnifier/Getting-Started.md
new file mode 100644
index 0000000000..ff737f549a
--- /dev/null
+++ b/wpf/Magnifier/Getting-Started.md
@@ -0,0 +1,155 @@
+---
+layout: post
+title: Getting Started with WPF Magnifier control | Syncfusion®
+description: Learn how to add and configure the WPF Magnifier control in your application with XAML and code examples.
+platform: wpf
+control: Magnifier
+documentation: ug
+---
+
+# Getting Started with WPF Magnifier
+
+This section guides you through the initial setup and basic usage of the [Magnifier](https://help.syncfusion.com/cr/wpf/Syncfusion.Windows.Shared.Magnifier.html) control in WPF applications. You will learn how to add the control to your application, attach it to a target element, and configure its basic properties.
+
+## Prerequisites
+
+Before you begin, ensure the following:
+
+### Assembly reference
+
+You can add the Syncfusion.Shared.WPF assembly reference to your WPF project using one of the following methods:
+
+**Option 1: NuGet Package (Recommended)**
+
+Install the [Syncfusion.Shared.WPF](https://www.nuget.org/packages/Syncfusion.Shared.WPF) NuGet package. It is recommended to install the latest version.
+
+Using Package Manager Console:
+```powershell
+Install-Package Syncfusion.Shared.WPF
+```
+
+Using .NET CLI:
+```bash
+dotnet add package Syncfusion.Shared.WPF
+```
+
+**Option 2: Assembly Reference**
+
+Add a direct reference to `Syncfusion.Shared.WPF.dll` from the installed location in your WPF project.
+
+
+**Option 2: Adding control via Designer**
+
+`Magnifier` control can be added to the application by dragging it from `Toolbox` and dropping it in Designer view. The required assembly references will be added automatically.
+
+### Namespace declaration
+
+Import the Syncfusion namespace in your XAML or code files.
+
+**XAML:**
+```xml
+xmlns:syncfusion="clr-namespace:Syncfusion.Windows.Shared;assembly=Syncfusion.Shared.WPF"
+```
+
+**C#:**
+```csharp
+using Syncfusion.Windows.Shared;
+```
+
+## Adding Magnifier using XAML
+
+You can declaratively add a Magnifier in XAML using the [`Magnifier.Current`](https://help.syncfusion.com/cr/wpf/Syncfusion.Windows.Shared.Magnifier.html#Syncfusion_Windows_Shared_Magnifier_CurrentProperty) attached property. This attaches a magnifier instance to any UI element.
+
+```xml
+
+
+
+
+
+
+
+```
+
+**In this example:**
+* The `Magnifier.Current` attached property is set on the `Grid` element
+* The magnifier automatically targets the `Grid` and all its children
+* The magnifier appears when the mouse enters the grid and hides when it leaves
+
+## Adding Magnifier using C#
+
+You can create and attach a magnifier programmatically using either the [`TargetElement`](https://help.syncfusion.com/cr/wpf/Syncfusion.Windows.Shared.Magnifier.html#Syncfusion_Windows_Shared_Magnifier_TargetElement) property or the [`SetCurrent`](https://help.syncfusion.com/cr/wpf/Syncfusion.Windows.Shared.Magnifier.html#Syncfusion_Windows_Shared_Magnifier_SetCurrent_System_Windows_DependencyObject_Syncfusion_Windows_Shared_Magnifier_) method.
+
+### Method 1: Using TargetElement Property
+
+```csharp
+// Create magnifier and set TargetElement property
+targetElementMagnifier = new Magnifier
+{
+ ZoomFactor = 0.4,
+ FrameType = FrameType.Rectangle,
+ FrameWidth = 200,
+ FrameHeight = 200,
+ FrameBackground = Brushes.LightBlue,
+ TargetElement = TargetElementExample // Assign target element
+};
+```
+
+### Method 2: Using SetCurrent Method
+
+```csharp
+// Create magnifier and attach using SetCurrent method
+setCurrentMagnifier = new Magnifier
+{
+ ZoomFactor = 0.35,
+ FrameType = FrameType.RoundedRectangle,
+ FrameWidth = 220,
+ FrameHeight = 180,
+ FrameCornerRadius = 15,
+ FrameBackground = Brushes.White
+};
+Magnifier.SetCurrent(SetCurrentExample, setCurrentMagnifier);
+```
+
+**Note:** Both methods achieve the same result. Use `TargetElement` property when you want to set the target as part of property initialization, or use `SetCurrent` method when you prefer a static helper approach.
+
+**Magnifier Demo**
+
+
+
+## Key properties and behavior
+
+### ZoomFactor
+
+The [`ZoomFactor`](https://help.syncfusion.com/cr/wpf/Syncfusion.Windows.Shared.Magnifier.html#Syncfusion_Windows_Shared_Magnifier_ZoomFactor) property determines the relative size of the area displayed inside the magnifier frame. It accepts values between `0.0` and `1.0`:
+
+* **Lower values** (e.g., `0.2`) provide higher magnification (smaller area is shown, but more zoomed in).
+* **Higher values** (e.g., `0.8`) provide lower magnification (larger area is shown with less zoom).
+* **Value of `1.0`** shows the content at its original size (no magnification).
+
+The `ZoomFactor` property is automatically coerced to this range:
+* Values greater than `1.0` are set to `1.0`.
+* Values less than `0.0` are set to minimum value slightly greater than `0.0`.
+
+### FrameType
+
+The [`FrameType`](https://help.syncfusion.com/cr/wpf/Syncfusion.Windows.Shared.Magnifier.html#Syncfusion_Windows_Shared_Magnifier_FrameType) property determines the shape of the magnifier frame. Available options:
+
+* **Rectangle**: A rectangular frame with configurable width and height.
+* **RoundedRectangle**: A rectangular frame with rounded corners (configurable corner radius).
+* **Circle**: A circular frame with configurable radius.
+
+### Visibility behavior
+
+The magnifier automatically manages its visibility based on mouse pointer position:
+
+* **Shows**: When the mouse pointer enters the bounds of the `TargetElement`.
+* **Hides**: When the mouse pointer leaves the bounds of the `TargetElement`.
+
+This behavior ensures the magnifier appears only when needed and does not interfere with the rest of the UI when inactive.
+
+
+
diff --git a/wpf/Magnifier/Overview.md b/wpf/Magnifier/Overview.md
new file mode 100644
index 0000000000..667791d063
--- /dev/null
+++ b/wpf/Magnifier/Overview.md
@@ -0,0 +1,35 @@
+---
+layout: post
+title: About WPF Magnifier control | Syncfusion®
+description: Learn about the WPF Magnifier control, its features, and usage scenarios for visual content magnification.
+platform: wpf
+control: Magnifier
+documentation: ug
+---
+
+# WPF Magnifier Overview
+
+The Magnifier control displays a zoomed view of UI content in a movable frame that follows the mouse pointer. It helps users inspect small elements or details without changing the application layout.
+
+## Key Features
+
+* **Multiple frame shapes** - Display magnified content in Rectangle, RoundedRectangle, or Circle frames.
+* **Configurable zoom levels** - Control magnification using the ZoomFactor property with values between 0 and 1.
+* **Automatic activation** - The magnifier appears when the mouse enters the target element and hides when it leaves.
+* **Flexible attachment** - Attach to any UIElement using XAML attached properties or code-behind.
+* **Customizable appearance** - Set frame size, background color, corner radius, and other visual properties.
+* **Export capabilities** - Save magnified content to image files or copy to clipboard.
+
+## Magnifier Demo
+
+
+
+## Use Cases
+
+The Magnifier control is useful when users need to examine UI content more closely without permanently zooming the entire interface. Common scenarios include:
+
+* **Accessibility** - Helps users with visual impairments read small text and UI elements.
+* **Data inspection** - Allows detailed examination of charts, images, and complex visualizations.
+* **Precision tasks** - Supports design review and alignment verification where exact details matter.
+
+The control works as an overlay and does not affect the layout or structure of your application. It provides temporary magnification that appears on demand and disappears when not needed.
diff --git a/wpf/Magnifier/Styling-and-Appearance.md b/wpf/Magnifier/Styling-and-Appearance.md
new file mode 100644
index 0000000000..a957cef8e0
--- /dev/null
+++ b/wpf/Magnifier/Styling-and-Appearance.md
@@ -0,0 +1,243 @@
+---
+layout: post
+title: Appearance and Styling in WPF Magnifier | Syncfusion®
+description: Learn how to customize the appearance and styling of the WPF Magnifier control including frame types, colors, and visual properties.
+platform: wpf
+control: Magnifier
+documentation: ug
+---
+
+# Styling and Appearance
+
+The Magnifier control provides extensive customization options to match your application's visual design. You can configure the frame shape, size, colors, and other visual properties to create the desired appearance.
+
+## Frame Types
+
+The [`FrameType`](https://help.syncfusion.com/cr/wpf/Syncfusion.Windows.Shared.Magnifier.html#Syncfusion_Windows_Shared_Magnifier_FrameType) property determines the shape of the magnifier frame. Three frame types are available:
+
+* **Rectangle** - A standard rectangular frame with sharp corners
+* **RoundedRectangle** - A rectangular frame with rounded corners
+* **Circle** - A circular frame
+
+### Rectangle Frame
+
+The Rectangle frame type displays the magnified content in a rectangular shape. Configure the size using the [`FrameWidth`](https://help.syncfusion.com/cr/wpf/Syncfusion.Windows.Shared.Magnifier.html#Syncfusion_Windows_Shared_Magnifier_FrameWidth) and [`FrameHeight`](https://help.syncfusion.com/cr/wpf/Syncfusion.Windows.Shared.Magnifier.html#Syncfusion_Windows_Shared_Magnifier_FrameHeight) properties.
+
+**XAML Example:**
+
+```xml
+
+
+
+```
+
+**C# Example:**
+
+```csharp
+var magnifier = new Magnifier
+{
+ FrameType = FrameType.Rectangle,
+ FrameWidth = 300,
+ FrameHeight = 200,
+ FrameBackground = Brushes.White,
+ ZoomFactor = 0.3
+};
+Magnifier.SetCurrent(targetElement, magnifier);
+```
+
+### RoundedRectangle Frame
+
+The RoundedRectangle frame type provides a softer appearance with rounded corners. Use the [`FrameCornerRadius`](https://help.syncfusion.com/cr/wpf/Syncfusion.Windows.Shared.Magnifier.html#Syncfusion_Windows_Shared_Magnifier_FrameCornerRadius) property to control the degree of rounding.
+
+**XAML Example:**
+
+```xml
+
+
+
+```
+
+**C# Example:**
+
+```csharp
+var magnifier = new Magnifier
+{
+ FrameType = FrameType.RoundedRectangle,
+ FrameWidth = 280,
+ FrameHeight = 180,
+ FrameCornerRadius = 20,
+ FrameBackground = new SolidColorBrush(Colors.AliceBlue),
+ ZoomFactor = 0.4
+};
+Magnifier.SetCurrent(targetElement, magnifier);
+```
+
+### Circle Frame
+
+The Circle frame type displays the magnified content in a circular shape. Configure the size using the [`FrameRadius`](https://help.syncfusion.com/cr/wpf/Syncfusion.Windows.Shared.Magnifier.html#Syncfusion_Windows_Shared_Magnifier_FrameRadius) property.
+
+**XAML Example:**
+
+```xml
+
+
+
+```
+
+**C# Example:**
+
+```csharp
+var magnifier = new Magnifier
+{
+ FrameType = FrameType.Circle,
+ FrameRadius = 120,
+ FrameBackground = new SolidColorBrush(Colors.WhiteSmoke),
+ ZoomFactor = 0.35
+};
+Magnifier.SetCurrent(targetElement, magnifier);
+```
+
+
+
+## Frame Background
+
+The [`FrameBackground`](https://help.syncfusion.com/cr/wpf/Syncfusion.Windows.Shared.Magnifier.html#Syncfusion_Windows_Shared_Magnifier_FrameBackground) property sets the background color or brush for the magnifier frame. This helps distinguish the magnified content from the underlying UI.
+
+### Solid Color Background
+
+**XAML:**
+
+```xml
+
+```
+
+**C#:**
+
+```csharp
+magnifier.FrameBackground = Brushes.LightGray;
+// Or using color
+magnifier.FrameBackground = new SolidColorBrush(Color.FromRgb(211, 211, 211));
+```
+
+### Gradient Background
+
+**XAML:**
+
+```xml
+
+
+
+
+
+
+
+
+```
+
+**C#:**
+
+```csharp
+var gradientBrush = new LinearGradientBrush
+{
+ StartPoint = new Point(0, 0),
+ EndPoint = new Point(1, 1)
+};
+gradientBrush.GradientStops.Add(new GradientStop(Colors.White, 0));
+gradientBrush.GradientStops.Add(new GradientStop(Colors.LightBlue, 1));
+magnifier.FrameBackground = gradientBrush;
+```
+
+
+
+## Size Configuration
+
+Configure the magnifier frame size based on the selected frame type.
+
+### Rectangle and RoundedRectangle Size
+
+For Rectangle and RoundedRectangle frames, use `FrameWidth` and `FrameHeight`:
+
+```csharp
+magnifier.FrameType = FrameType.RoundedRectangle;
+magnifier.FrameWidth = 320; // Width in pixels
+magnifier.FrameHeight = 240; // Height in pixels
+```
+
+### Circle Size
+
+For Circle frames, use `FrameRadius`:
+
+```csharp
+magnifier.FrameType = FrameType.Circle;
+magnifier.FrameRadius = 150; // Radius in pixels (diameter = 300)
+```
+
+## Common Styling Scenarios
+
+### Subtle Inspection Magnifier
+
+A semi-transparent magnifier for non-intrusive content inspection:
+
+```xml
+
+```
+
+### High-Contrast Magnifier
+
+A bold magnifier for clear visual distinction:
+
+```xml
+
+```
+
+### Modern Rounded Magnifier
+
+A contemporary design with soft edges:
+
+```xml
+
+```
+
+
+
+## Best Practices
+
+* **Choose appropriate frame types**: Use Circle for general inspection, Rectangle for detailed analysis of rectangular content.
+* **Background contrast**: Select frame backgrounds that provide good contrast with your UI for better visibility.
+* **Size considerations**: Larger frames provide more context but can obscure more of the underlying UI. Balance between visibility and usability.
+* **Corner radius**: For RoundedRectangle frames, a corner radius of 15-25 pixels typically provides a good balance between aesthetics and usability.
+* **ZoomFactor coordination**: Adjust ZoomFactor along with frame size. Larger frames may work better with higher ZoomFactor values (0.4-0.6), while smaller frames benefit from lower values (0.2-0.4).
diff --git a/wpf/Magnifier/resources/CommonStylingScenarios.gif b/wpf/Magnifier/resources/CommonStylingScenarios.gif
new file mode 100644
index 0000000000..ec838ae264
Binary files /dev/null and b/wpf/Magnifier/resources/CommonStylingScenarios.gif differ
diff --git a/wpf/Magnifier/resources/FrameBackground_Styles.gif b/wpf/Magnifier/resources/FrameBackground_Styles.gif
new file mode 100644
index 0000000000..9b541da29f
Binary files /dev/null and b/wpf/Magnifier/resources/FrameBackground_Styles.gif differ
diff --git a/wpf/Magnifier/resources/FrameTypes_Demo.gif b/wpf/Magnifier/resources/FrameTypes_Demo.gif
new file mode 100644
index 0000000000..b0f8f12a66
Binary files /dev/null and b/wpf/Magnifier/resources/FrameTypes_Demo.gif differ
diff --git a/wpf/Magnifier/resources/Magnifier_Demonstration.gif b/wpf/Magnifier/resources/Magnifier_Demonstration.gif
new file mode 100644
index 0000000000..65afbfe622
Binary files /dev/null and b/wpf/Magnifier/resources/Magnifier_Demonstration.gif differ
diff --git a/wpf/Magnifier/resources/exported_images.png b/wpf/Magnifier/resources/exported_images.png
new file mode 100644
index 0000000000..31b57360e8
Binary files /dev/null and b/wpf/Magnifier/resources/exported_images.png differ
diff --git a/wpf/Magnifier/resources/magnifier_active_vs_inactive_comparison.png b/wpf/Magnifier/resources/magnifier_active_vs_inactive_comparison.png
new file mode 100644
index 0000000000..b9aa86b97f
Binary files /dev/null and b/wpf/Magnifier/resources/magnifier_active_vs_inactive_comparison.png differ
diff --git a/wpf/Magnifier/resources/zooming-features.gif b/wpf/Magnifier/resources/zooming-features.gif
new file mode 100644
index 0000000000..0eeaf29780
Binary files /dev/null and b/wpf/Magnifier/resources/zooming-features.gif differ