Preview: MewUI v0.16.0 Release Notes

[al6uiz]

This will be the first MewUI release in about a month, and it includes a larger set of changes than usual.
The main focus of this release is the new GPU-accelerated rendering and interop foundation, which enables the new SVG renderer, Skia integration(as library), and video playback sample.

This preview is intended to share the upcoming changes before the final release.

---

What's Changed

This release introduces a new GPU-accelerated rendering and interop foundation for MewUI.
It replaces the previous offscreen render-target abstraction with the new IRenderSurface / IRenderDevice model, adds external GPU/raster interop paths, and introduces a GPU-accelerated image filter graph.

The most visible results of this work are the new MewUI.Svg library, MewUI.Skia integration, and the FFmpeg-based video playback sample.

On top of that foundation, this release adds several user-facing features, including the ColorPicker control and a live hierarchical performance profiler.
It also includes major backend improvements such as asynchronous OpenGL PBO uploads, Win32 transparent windows backed by DirectComposition, a shared D3D11 device across Direct2D consumers, and a 1:1 BitBlt fast path for external GDI DIBs.

Because the release contains breaking changes across backend interfaces and the platform-surface namespace, custom backends, WriteableBitmapControl, and code that uses platform-surface interfaces will need to be migrated.

⚠️ Breaking Changes

Rendering abstraction

• IBitmapRenderTarget removed — Offscreen render targets are replaced by the new IRenderSurface. Surface creation now flows through RenderSurfaceDescriptor (pixel format / size / DPI / usage intent / lifetime hint) and a capability-interface model.
• IGraphicsFactory.CreateBitmapRenderTarget(...) removed — IGraphicsFactory now extends the new IRenderDevice; callers create surfaces via CreateSurface(RenderSurfaceDescriptor).
• IGraphicsFactory.CreateImageFromPixelSource(...) renamed to CreateImageView(IPixelBufferSource).
• Window.RenderFrameToSurface signature changed — IBitmapRenderTarget → IRenderSurface.
• Direct2DBitmapRenderTarget / GdiBitmapRenderTarget / OpenGLBitmapRenderTarget / MewVGMetalBitmapRenderTarget removed — replaced by each backend's *PixelRenderSurface implementation.

Backend / platform

• GraphicsBackend enum removed — backend identification moved from an enum to a string name (Backend property). The backend name matches the <Name> portion of the package name MewUI.Backend.<Name> ("Direct2D", "Gdi", "MewVG.Win32", "MewVG.X11", "MewVG.MacOS"). Code that branched on the enum must switch to string comparison.
• Platform/Surfaces/I* interface files moved to Shared/Platform/{Win32,MacOS,Linux/X11}/ — IWin32WindowSurface, IWin32TransparencyCapabilities, IMacOSWindowSurface, IX11GlxWindowSurface, etc. relocated to platform folders. Namespaces (Aprillz.MewUI.Platform.{Win32,MacOS,Linux.X11}) are unchanged, so ordinary consumer code is unaffected; only custom csproj files that include these paths via explicit <Compile Include> need their paths updated.
• IWindowSurfaceSelector and IWin32LayeredWindowSurface removed — no longer referenced; equivalent roles are exposed via backend capability interfaces.

Resources / controls

• IExternalLockedTexture replaced by IRasterSource — the external texture interop contract moved from a lock-based model to a raster-source model. Adapters such as ExternalSampleSource and ExternalLockedTextureSampleSource are consolidated into ExternalRasterSource.
• IPixelBufferSource gains HasAlpha and LockMode members — default implementations are provided, so most code is unaffected; explicit implementors may see compiler warnings.
• WriteableBitmapControl removed — for simple display, assign a WriteableBitmap directly to Image.Source (WriteableBitmap implements IImageSource); for pixel drawing combined with interaction, wrap it with IGraphicsFactory.CreateImageView to obtain an IImage and call DrawImage from FrameworkElement.OnRender. Existing OnRenderPixels / LockForWrite / UseBitmapGraphicsContext callers must migrate.

Added

Libraries / samples

• MewUI.Svg library — SVG rendering that uses the GPU interop path to composite directly onto each backend's GPU surface.
• MewUI.Skia library — Skia integration over the GPU interop path. Composes Skia (SKCanvas) content zero-copy inside the MewUI control tree. Ships per-backend interop bridges for Direct2D, GDI, MewVG.Win32, MewVG.X11, and MewVG.MacOS.
• FFmpeg-based video playback sample — MewUI.Video.Sample, with NVDEC hardware-decode fallback. Decoder frames are displayed without a copy through the external GPU interop path.

Rendering / backend

• Image filter graph — an ImageFilter node graph evaluated through IImageFilterContext / ScratchSurfacePool. Ships with a CPU reference executor and Direct2D / Metal / OpenGL GPU executors, plus a separable Gaussian blur as a built-in node.
• External GPU / raster interop — IRasterSource, ExternalRasterSource, ExternalGpuWriteScope, GpuInteropInvalidation, and GpuResourceAffinity expose externally owned or GPU-resident textures as IImage without copy, and manage write scopes and invalidation for shared GPU resources. On Win32, D3D11 surfaces are shared into OpenGL contexts via WGL_NV_DX_interop.
• Shared D3D11 device across Direct2D consumers — D3D11RenderTargetDeviceProvider lets multiple D2D consumers (GPU surfaces, DXGI images, etc.) reuse a single D3D11 device, removing duplicate device creation and cross-context state churn.
• External DIB image + 1:1 BitBlt fast path (GDI) — externally owned DIBs are wrapped as IImage without an intermediate copy, and matching source/destination rectangles take a direct BitBlt path instead of StretchBlt, improving both pixel accuracy and cost.
• Asynchronous OpenGL PBO uploads — a pool of PBO + fence-sync uploaders eliminates per-frame texture upload stalls.
• IGraphicsContext extensions — SetClipPath(PathGeometry) and GetClipBoundsLocal().
• IImageBrush + TileMode — image / pattern fill brush (maps to SVG pattern and patternTransform).
• PathGeometry.Transform(Matrix3x2) — bakes a transform matrix into the geometry so that a subsequent Stroke preserves element-DIP thickness.
• IGlyphOutlineFont — every font backend can extract glyph outlines as PathGeometry, with synthetic bold / italic support.
• HasAlpha flag on bitmap resources — skips GPU blending cost for sources that do not carry alpha.

Platform

• Win32 transparent-window mode abstraction — IWin32TransparencyCapabilities exposes which mode (layered HWND / DirectComposition / opaque) each backend supports. Includes DirectComposition native bindings such as DCompositionCreateDevice.

Controls

• ColorPicker control — a drop-down color picker with HSV color wheel, alpha slider, and hex entry. Adds the HsvColor struct.
• Grid.ShareStarSize property — share star sizing across multiple Grids.
• NumericUpDown.IsInteger mode — integer-only input.

Core

• AffectsVisualState attribute — declares that a dependency-property change should automatically trigger visual-state refresh.
• ISubtreeInvalidationHost — host for subtree-scoped layout invalidation.
• Read-only dependency property support.

Text

• Stronger text rendering caching — reduces layout recomputation and GPU texture reallocation for menu / dynamic text, lowering render cost for frequently drawn text.

Diagnostics

• Hierarchical performance profiler — measures layout / render / animation cost per frame and ships a live overlay and timeline debug UI. Debug-build only; toggle the overlay with Ctrl+Shift+P and the timeline window with Ctrl+Alt+Shift+P.

Improved

Rendering / backend

• Unified all graphics backends on *PixelRenderSurface — Direct2D ships both a CPU-readable variant and a copy-free GPU (DXGI) variant. The GDI implementation is renamed to GdiPixelRenderSurface.
• Asynchronous OpenGL rendering — a background render scope lets offscreen work such as image filters run on worker threads, and the resulting textures are sampled by the UI thread without a pixel copy.
• MewVG window / context lifecycle stabilization — context acquisition, the offscreen surface provider, and per-window resource teardown are aligned on a shared contract across Win32 / X11 / macOS, reducing the surface area for races and leaks.
• Hardened WGL DX interop and PBO upload paths — WGL_NV_DX_interop locking and texture lifecycle are stabilized under context-loss conditions, and the PBO fence pool retires more robustly under sustained pressure.
• Metal coverage-AA attachment and dynamic presentsWithTransaction management.
• AA applied to rotated images in the MewVG backend.
• Backend projects now reference platform projects — every MewUI.Backend.* csproj has been adjusted to ProjectReference the matching MewUI.Platform.* project, and duplicate-compiled shared types such as InlineArrays.cs are now built in a single location.

Text

• CoreText rendering via CTLine — measured and rendered widths now match, improving alignment accuracy and kerning / ligature handling.
• PNG decoder support for 1 / 2 / 4-bit grayscale and indexed formats.
• Improved stability of Linux font fallback.
• Selection highlight is hidden when the window is inactive or the control is unfocused.

Controls / layout

• Shape stretch handling — bakes the stretch transform into the geometry so that StrokeThickness stays in element-DIP.
• ScrollViewer updates scroll state during Arrange — removes side effects from the Measure phase.
• Improved ScrollViewer variable-height estimation and anchor correction — reduces viewport jumps when item sizes settle.
• TabControl no longer wraps content in an internal ScrollViewer; TabItem content uses an independent ScrollViewer instead.
• Improved focus redirection for mouse and programmatic input.

Core / performance

• General memory / GC pressure reduction — CollectionPool, PathGeometry caching, BorderGeometry extraction, stackalloc for dash patterns, in-place BGRA↔RGBA conversion, pre-parsed AccessKey, FormattedTextStore measurement-constraint caching, and more.
• MewObject property storage and inheritance handling optimized.

Fixed

Backend / platform

• BadDrawable on X11 window destruction — GL resources are now released before XDestroyWindow.
• macOS `Cmd+`` "next window" shortcut — now forwarded to AppKit.
• MewVG Metal image edge artifacts removed.

Controls / layout

• Layout invalidation no longer fails to propagate to the parent ([Bug]: ComboBox drop-down list does not update when scrolled #125).
• TabHeaderButton clicks on focusable descendants (e.g., close button) are now delegated correctly.
• Selected item is now restored correctly after a tab is removed.
• Panel hit-testing now culls against Bounds first.
• ScrollViewer scroll events no longer close unrelated transient popups (now scoped to relevant descendants).
• Window adorner cleanup, clipping, and transform handling stabilized.

Text / resources

• TextBoxView caret padding corrected when no text has been entered.
• Multi-subpath SVG no longer misinterprets relative coordinates right after a closepath (Fixed handling of multi-subpath SVGs that use relative coordinates immediately after the previous subpath was closed #114).

---

Full Changelog: v0.15.2...v0.16.0

[al6uiz]

Added TabControl.TabPlacement.

TabControl now supports header placement through TabPlacement, allowing tab headers to be placed at Top, Bottom, Left, or Right.

Also added RotationDecorator, which can rotate child elements by 90 or -90 degrees. This is useful for controls that need vertical headers or rotated content, such as side-positioned tab headers.

With these changes, layouts like the one below can now be implemented directly.

[al6uiz]

Added cross-window drag and drop support.

MewUI now supports drag and drop between windows on all supported platforms.

This makes it possible to start a drag operation from one MewUI window and drop it into another window within the same application.

The drag preview can also be represented as a separate preview window, allowing custom window-based preview visuals during the drag operation.