Merge branch 'dev' into pip-fix-macos

Avalonia.Gif/Avalonia.Gif.csproj

@@ -0,0 +1,17 @@
+<Project Sdk="Microsoft.NET.Sdk">
+	<PropertyGroup>
+		<TargetFramework>net8.0</TargetFramework>
+		<LangVersion>latest</LangVersion> 
+		<AllowUnsafeBlocks>true</AllowUnsafeBlocks> 
+		<RuntimeIdentifiers>win-x64;linux-x64;osx-x64;osx-arm64</RuntimeIdentifiers>
+		<ImplicitUsings>enable</ImplicitUsings>
+		<Nullable>enable</Nullable>
+		<BuiltInComInteropSupport>true</BuiltInComInteropSupport>
+		<EnableWindowsTargeting>true</EnableWindowsTargeting>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Avalonia" Version="11.0.5" />
+    <PackageReference Include="SkiaSharp" Version="2.88.6" />
+  </ItemGroup>
+
+</Project>

Avalonia.Gif/BgWorkerCommand.cs

@@ -0,0 +1,10 @@
+namespace Avalonia.Gif
+{
+    internal enum BgWorkerCommand
+    {
+        Null,
+        Play,
+        Pause,
+        Dispose
+    }
+}

Avalonia.Gif/BgWorkerState.cs

@@ -0,0 +1,12 @@
+namespace Avalonia.Gif
+{
+    internal enum BgWorkerState
+    {
+        Null,
+        Start,
+        Running,
+        Paused,
+        Complete,
+        Dispose
+    }
+}

Avalonia.Gif/Decoding/BlockTypes.cs

@@ -0,0 +1,10 @@
+namespace Avalonia.Gif.Decoding
+{
+    internal enum BlockTypes
+    {
+        Empty = 0,
+        Extension = 0x21,
+        ImageDescriptor = 0x2C,
+        Trailer = 0x3B,
+    }
+}

Avalonia.Gif/Decoding/ExtensionType.cs

@@ -0,0 +1,8 @@
+namespace Avalonia.Gif.Decoding
+{
+    internal enum ExtensionType
+    {
+        GraphicsControl = 0xF9,
+        Application = 0xFF
+    }
+}

Avalonia.Gif/Decoding/FrameDisposal.cs

@@ -0,0 +1,10 @@
+namespace Avalonia.Gif.Decoding
+{
+    public enum FrameDisposal
+    {
+        Unknown = 0,
+        Leave = 1,
+        Background = 2,
+        Restore = 3
+    }
+}

Avalonia.Gif/Decoding/GifColor.cs

@@ -0,0 +1,36 @@
+using System.Runtime.InteropServices;
+
+namespace Avalonia.Gif
+{
+    [StructLayout(LayoutKind.Explicit)]
+    public readonly struct GifColor
+    {
+        [FieldOffset(3)]
+        public readonly byte A;
+
+        [FieldOffset(2)]
+        public readonly byte R;
+
+        [FieldOffset(1)]
+        public readonly byte G;
+
+        [FieldOffset(0)]
+        public readonly byte B;
+
+        /// <summary>
+        /// A struct that represents a ARGB color and is aligned as
+        /// a BGRA bytefield in memory.
+        /// </summary>
+        /// <param name="r">Red</param>
+        /// <param name="g">Green</param>
+        /// <param name="b">Blue</param>
+        /// <param name="a">Alpha</param>
+        public GifColor(byte r, byte g, byte b, byte a = byte.MaxValue)
+        {
+            A = a;
+            R = r;
+            G = g;
+            B = b;
+        }
+    }
+}

Avalonia.Gif/Decoding/GifDecoder.cs

@@ -0,0 +1,653 @@
+// This source file's Lempel-Ziv-Welch algorithm is derived from Chromium's Android GifPlayer
+// as seen here (https://github.com/chromium/chromium/blob/master/third_party/gif_player/src/jp/tomorrowkey/android/gifplayer)
+// Licensed under the Apache License, Version 2.0 (https://www.apache.org/licenses/LICENSE-2.0)
+// Copyright (C) 2015 The Gifplayer Authors. All Rights Reserved.
+
+// The rest of the source file is licensed under MIT License.
+// Copyright (C) 2018 Jumar A. Macato, All Rights Reserved.
+
+using System;
+using System.Buffers;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading;
+using Avalonia;
+using Avalonia.Media.Imaging;
+using static Avalonia.Gif.Extensions.StreamExtensions;
+
+namespace Avalonia.Gif.Decoding
+{
+    public sealed class GifDecoder : IDisposable
+    {
+        private static readonly ReadOnlyMemory<byte> G87AMagic = "GIF87a"u8.ToArray().AsMemory();
+
+        private static readonly ReadOnlyMemory<byte> G89AMagic = "GIF89a"u8.ToArray().AsMemory();
+
+        private static readonly ReadOnlyMemory<byte> NetscapeMagic = "NETSCAPE2.0"u8.ToArray().AsMemory();
+
+        private static readonly TimeSpan FrameDelayThreshold = TimeSpan.FromMilliseconds(10);
+        private static readonly TimeSpan FrameDelayDefault = TimeSpan.FromMilliseconds(100);
+        private static readonly GifColor TransparentColor = new(0, 0, 0, 0);
+        private static readonly int MaxTempBuf = 768;
+        private static readonly int MaxStackSize = 4096;
+        private static readonly int MaxBits = 4097;
+
+        private readonly Stream _fileStream;
+        private readonly CancellationToken _currentCtsToken;
+        private readonly bool _hasFrameBackups;
+
+        private int _gctSize,
+            _bgIndex,
+            _prevFrame = -1,
+            _backupFrame = -1;
+        private bool _gctUsed;
+
+        private GifRect _gifDimensions;
+
+        // private ulong _globalColorTable;
+        private readonly int _backBufferBytes;
+        private GifColor[] _bitmapBackBuffer;
+
+        private short[] _prefixBuf;
+        private byte[] _suffixBuf;
+        private byte[] _pixelStack;
+        private byte[] _indexBuf;
+        private byte[] _backupFrameIndexBuf;
+        private volatile bool _hasNewFrame;
+
+        public GifHeader Header { get; private set; }
+
+        public readonly List<GifFrame> Frames = new();
+
+        public PixelSize Size => new PixelSize(Header.Dimensions.Width, Header.Dimensions.Height);
+
+        public GifDecoder(Stream fileStream, CancellationToken currentCtsToken)
+        {
+            _fileStream = fileStream;
+            _currentCtsToken = currentCtsToken;
+
+            ProcessHeaderData();
+            ProcessFrameData();
+
+            Header.IterationCount = Header.Iterations switch
+            {
+                -1 => new GifRepeatBehavior { Count = 1 },
+                0 => new GifRepeatBehavior { LoopForever = true },
+                > 0 => new GifRepeatBehavior { Count = Header.Iterations },
+                _ => Header.IterationCount
+            };
+
+            var pixelCount = _gifDimensions.TotalPixels;
+
+            _hasFrameBackups = Frames.Any(f => f.FrameDisposalMethod == FrameDisposal.Restore);
+
+            _bitmapBackBuffer = new GifColor[pixelCount];
+            _indexBuf = new byte[pixelCount];
+
+            if (_hasFrameBackups)
+                _backupFrameIndexBuf = new byte[pixelCount];
+
+            _prefixBuf = new short[MaxStackSize];
+            _suffixBuf = new byte[MaxStackSize];
+            _pixelStack = new byte[MaxStackSize + 1];
+
+            _backBufferBytes = pixelCount * Marshal.SizeOf(typeof(GifColor));
+        }
+
+        public void Dispose()
+        {
+            Frames.Clear();
+
+            _bitmapBackBuffer = null;
+            _prefixBuf = null;
+            _suffixBuf = null;
+            _pixelStack = null;
+            _indexBuf = null;
+            _backupFrameIndexBuf = null;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private int PixCoord(int x, int y) => x + y * _gifDimensions.Width;
+
+        static readonly (int Start, int Step)[] Pass = { (0, 8), (4, 8), (2, 4), (1, 2) };
+
+        private void ClearImage()
+        {
+            Array.Fill(_bitmapBackBuffer, TransparentColor);
+            //ClearArea(_gifDimensions);
+
+            _prevFrame = -1;
+            _backupFrame = -1;
+        }
+
+        public void RenderFrame(int fIndex, WriteableBitmap writeableBitmap, bool forceClear = false)
+        {
+            if (_currentCtsToken.IsCancellationRequested)
+                return;
+
+            if (fIndex < 0 | fIndex >= Frames.Count)
+                return;
+
+            if (_prevFrame == fIndex)
+                return;
+
+            if (fIndex == 0 || forceClear || fIndex < _prevFrame)
+                ClearImage();
+
+            DisposePreviousFrame();
+
+            _prevFrame++;
+
+            // render intermediate frame
+            for (int idx = _prevFrame; idx < fIndex; ++idx)
+            {
+                var prevFrame = Frames[idx];
+
+                if (prevFrame.FrameDisposalMethod == FrameDisposal.Restore)
+                    continue;
+
+                if (prevFrame.FrameDisposalMethod == FrameDisposal.Background)
+                {
+                    ClearArea(prevFrame.Dimensions);
+                    continue;
+                }
+
+                RenderFrameAt(idx, writeableBitmap);
+            }
+
+            RenderFrameAt(fIndex, writeableBitmap);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private void RenderFrameAt(int idx, WriteableBitmap writeableBitmap)
+        {
+            var tmpB = ArrayPool<byte>.Shared.Rent(MaxTempBuf);
+
+            var curFrame = Frames[idx];
+            DecompressFrameToIndexBuffer(curFrame, _indexBuf, tmpB);
+
+            if (_hasFrameBackups & curFrame.ShouldBackup)
+            {
+                Buffer.BlockCopy(_indexBuf, 0, _backupFrameIndexBuf, 0, curFrame.Dimensions.TotalPixels);
+                _backupFrame = idx;
+            }
+
+            DrawFrame(curFrame, _indexBuf);
+
+            _prevFrame = idx;
+            _hasNewFrame = true;
+
+            using var lockedBitmap = writeableBitmap.Lock();
+            WriteBackBufToFb(lockedBitmap.Address);
+
+            ArrayPool<byte>.Shared.Return(tmpB);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private void DrawFrame(GifFrame curFrame, Memory<byte> frameIndexSpan)
+        {
+            var activeColorTable = curFrame.IsLocalColorTableUsed ? curFrame.LocalColorTable : Header.GlobarColorTable;
+
+            var cX = curFrame.Dimensions.X;
+            var cY = curFrame.Dimensions.Y;
+            var cH = curFrame.Dimensions.Height;
+            var cW = curFrame.Dimensions.Width;
+            var tC = curFrame.TransparentColorIndex;
+            var hT = curFrame.HasTransparency;
+
+            if (curFrame.IsInterlaced)
+            {
+                for (var i = 0; i < 4; i++)
+                {
+                    var curPass = Pass[i];
+                    var y = curPass.Start;
+                    while (y < cH)
+                    {
+                        DrawRow(y);
+                        y += curPass.Step;
+                    }
+                }
+            }
+            else
+            {
+                for (var i = 0; i < cH; i++)
+                    DrawRow(i);
+            }
+
+            //for (var row = 0; row < cH; row++)
+            void DrawRow(int row)
+            {
+                // Get the starting point of the current row on frame's index stream.
+                var indexOffset = row * cW;
+
+                // Get the target backbuffer offset from the frames coords.
+                var targetOffset = PixCoord(cX, row + cY);
+                var len = _bitmapBackBuffer.Length;
+
+                for (var i = 0; i < cW; i++)
+                {
+                    var indexColor = frameIndexSpan.Span[indexOffset + i];
+
+                    if (activeColorTable == null || targetOffset >= len || indexColor > activeColorTable.Length)
+                        return;
+
+                    if (!(hT & indexColor == tC))
+                        _bitmapBackBuffer[targetOffset] = activeColorTable[indexColor];
+
+                    targetOffset++;
+                }
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private void DisposePreviousFrame()
+        {
+            if (_prevFrame == -1)
+                return;
+
+            var prevFrame = Frames[_prevFrame];
+
+            switch (prevFrame.FrameDisposalMethod)
+            {
+                case FrameDisposal.Background:
+                    ClearArea(prevFrame.Dimensions);
+                    break;
+                case FrameDisposal.Restore:
+                    if (_hasFrameBackups && _backupFrame != -1)
+                        DrawFrame(Frames[_backupFrame], _backupFrameIndexBuf);
+                    else
+                        ClearArea(prevFrame.Dimensions);
+                    break;
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private void ClearArea(GifRect area)
+        {
+            for (var y = 0; y < area.Height; y++)
+            {
+                var targetOffset = PixCoord(area.X, y + area.Y);
+                for (var x = 0; x < area.Width; x++)
+                    _bitmapBackBuffer[targetOffset + x] = TransparentColor;
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private void DecompressFrameToIndexBuffer(GifFrame curFrame, Span<byte> indexSpan, byte[] tempBuf)
+        {
+            _fileStream.Position = curFrame.LzwStreamPosition;
+            var totalPixels = curFrame.Dimensions.TotalPixels;
+
+            // Initialize GIF data stream decoder.
+            var dataSize = curFrame.LzwMinCodeSize;
+            var clear = 1 << dataSize;
+            var endOfInformation = clear + 1;
+            var available = clear + 2;
+            var oldCode = -1;
+            var codeSize = dataSize + 1;
+            var codeMask = (1 << codeSize) - 1;
+
+            for (var code = 0; code < clear; code++)
+            {
+                _prefixBuf[code] = 0;
+                _suffixBuf[code] = (byte)code;
+            }
+
+            // Decode GIF pixel stream.
+            int bits,
+                first,
+                top,
+                pixelIndex;
+            var datum = bits = first = top = pixelIndex = 0;
+
+            while (pixelIndex < totalPixels)
+            {
+                var blockSize = _fileStream.ReadBlock(tempBuf);
+
+                if (blockSize == 0)
+                    break;
+
+                var blockPos = 0;
+
+                while (blockPos < blockSize)
+                {
+                    datum += tempBuf[blockPos] << bits;
+                    blockPos++;
+
+                    bits += 8;
+
+                    while (bits >= codeSize)
+                    {
+                        // Get the next code.
+                        var code = datum & codeMask;
+                        datum >>= codeSize;
+                        bits -= codeSize;
+
+                        // Interpret the code
+                        if (code == clear)
+                        {
+                            // Reset decoder.
+                            codeSize = dataSize + 1;
+                            codeMask = (1 << codeSize) - 1;
+                            available = clear + 2;
+                            oldCode = -1;
+                            continue;
+                        }
+
+                        // Check for explicit end-of-stream
+                        if (code == endOfInformation)
+                            return;
+
+                        if (oldCode == -1)
+                        {
+                            indexSpan[pixelIndex++] = _suffixBuf[code];
+                            oldCode = code;
+                            first = code;
+                            continue;
+                        }
+
+                        var inCode = code;
+                        if (code >= available)
+                        {
+                            _pixelStack[top++] = (byte)first;
+                            code = oldCode;
+
+                            if (top == MaxBits)
+                                ThrowException();
+                        }
+
+                        while (code >= clear)
+                        {
+                            if (code >= MaxBits || code == _prefixBuf[code])
+                                ThrowException();
+
+                            _pixelStack[top++] = _suffixBuf[code];
+                            code = _prefixBuf[code];
+
+                            if (top == MaxBits)
+                                ThrowException();
+                        }
+
+                        first = _suffixBuf[code];
+                        _pixelStack[top++] = (byte)first;
+
+                        // Add new code to the dictionary
+                        if (available < MaxStackSize)
+                        {
+                            _prefixBuf[available] = (short)oldCode;
+                            _suffixBuf[available] = (byte)first;
+                            available++;
+
+                            if ((available & codeMask) == 0 && available < MaxStackSize)
+                            {
+                                codeSize++;
+                                codeMask += available;
+                            }
+                        }
+
+                        oldCode = inCode;
+
+                        // Drain the pixel stack.
+                        do
+                        {
+                            indexSpan[pixelIndex++] = _pixelStack[--top];
+                        } while (top > 0);
+                    }
+                }
+            }
+
+            while (pixelIndex < totalPixels)
+                indexSpan[pixelIndex++] = 0; // clear missing pixels
+
+            void ThrowException() => throw new LzwDecompressionException();
+        }
+
+        /// <summary>
+        /// Directly copies the <see cref="GifColor"/> struct array to a bitmap IntPtr.
+        /// </summary>
+        private void WriteBackBufToFb(IntPtr targetPointer)
+        {
+            if (_currentCtsToken.IsCancellationRequested)
+                return;
+
+            if (!(_hasNewFrame & _bitmapBackBuffer != null))
+                return;
+
+            unsafe
+            {
+                fixed (void* src = &_bitmapBackBuffer[0])
+                    Buffer.MemoryCopy(src, targetPointer.ToPointer(), (uint)_backBufferBytes, (uint)_backBufferBytes);
+                _hasNewFrame = false;
+            }
+        }
+
+        /// <summary>
+        /// Processes GIF Header.
+        /// </summary>
+        private void ProcessHeaderData()
+        {
+            var str = _fileStream;
+            var tmpB = ArrayPool<byte>.Shared.Rent(MaxTempBuf);
+            var tempBuf = tmpB.AsSpan();
+
+            var _ = str.Read(tmpB, 0, 6);
+
+            if (!tempBuf[..3].SequenceEqual(G87AMagic[..3].Span))
+                throw new InvalidGifStreamException("Not a GIF stream.");
+
+            if (!(tempBuf[..6].SequenceEqual(G87AMagic.Span) | tempBuf[..6].SequenceEqual(G89AMagic.Span)))
+                throw new InvalidGifStreamException(
+                    "Unsupported GIF Version: " + Encoding.ASCII.GetString(tempBuf[..6].ToArray())
+                );
+
+            ProcessScreenDescriptor(tmpB);
+
+            Header = new GifHeader
+            {
+                Dimensions = _gifDimensions,
+                HasGlobalColorTable = _gctUsed,
+                // GlobalColorTableCacheID = _globalColorTable,
+                GlobarColorTable = ProcessColorTable(ref str, tmpB, _gctSize),
+                GlobalColorTableSize = _gctSize,
+                BackgroundColorIndex = _bgIndex,
+                HeaderSize = _fileStream.Position
+            };
+
+            ArrayPool<byte>.Shared.Return(tmpB);
+        }
+
+        /// <summary>
+        /// Parses colors from file stream to target color table.
+        /// </summary>
+        private static GifColor[] ProcessColorTable(ref Stream stream, byte[] rawBufSpan, int nColors)
+        {
+            var nBytes = 3 * nColors;
+            var target = new GifColor[nColors];
+
+            var n = stream.Read(rawBufSpan, 0, nBytes);
+
+            if (n < nBytes)
+                throw new InvalidOperationException("Wrong color table bytes.");
+
+            int i = 0,
+                j = 0;
+
+            while (i < nColors)
+            {
+                var r = rawBufSpan[j++];
+                var g = rawBufSpan[j++];
+                var b = rawBufSpan[j++];
+                target[i++] = new GifColor(r, g, b);
+            }
+
+            return target;
+        }
+
+        /// <summary>
+        /// Parses screen and other GIF descriptors.
+        /// </summary>
+        private void ProcessScreenDescriptor(byte[] tempBuf)
+        {
+            var width = _fileStream.ReadUShortS(tempBuf);
+            var height = _fileStream.ReadUShortS(tempBuf);
+
+            var packed = _fileStream.ReadByteS(tempBuf);
+
+            _gctUsed = (packed & 0x80) != 0;
+            _gctSize = 2 << (packed & 7);
+            _bgIndex = _fileStream.ReadByteS(tempBuf);
+
+            _gifDimensions = new GifRect(0, 0, width, height);
+            _fileStream.Skip(1);
+        }
+
+        /// <summary>
+        /// Parses all frame data.
+        /// </summary>
+        private void ProcessFrameData()
+        {
+            _fileStream.Position = Header.HeaderSize;
+
+            var tempBuf = ArrayPool<byte>.Shared.Rent(MaxTempBuf);
+
+            var terminate = false;
+            var curFrame = 0;
+
+            Frames.Add(new GifFrame());
+
+            do
+            {
+                var blockType = (BlockTypes)_fileStream.ReadByteS(tempBuf);
+
+                switch (blockType)
+                {
+                    case BlockTypes.Empty:
+                        break;
+
+                    case BlockTypes.Extension:
+                        ProcessExtensions(ref curFrame, tempBuf);
+                        break;
+
+                    case BlockTypes.ImageDescriptor:
+                        ProcessImageDescriptor(ref curFrame, tempBuf);
+                        _fileStream.SkipBlocks(tempBuf);
+                        break;
+
+                    case BlockTypes.Trailer:
+                        Frames.RemoveAt(Frames.Count - 1);
+                        terminate = true;
+                        break;
+
+                    default:
+                        _fileStream.SkipBlocks(tempBuf);
+                        break;
+                }
+
+                // Break the loop when the stream is not valid anymore.
+                if (_fileStream.Position >= _fileStream.Length & terminate == false)
+                    throw new InvalidProgramException("Reach the end of the filestream without trailer block.");
+            } while (!terminate);
+
+            ArrayPool<byte>.Shared.Return(tempBuf);
+        }
+
+        /// <summary>
+        /// Parses GIF Image Descriptor Block.
+        /// </summary>
+        private void ProcessImageDescriptor(ref int curFrame, byte[] tempBuf)
+        {
+            var str = _fileStream;
+            var currentFrame = Frames[curFrame];
+
+            // Parse frame dimensions.
+            var frameX = str.ReadUShortS(tempBuf);
+            var frameY = str.ReadUShortS(tempBuf);
+            var frameW = str.ReadUShortS(tempBuf);
+            var frameH = str.ReadUShortS(tempBuf);
+
+            frameW = (ushort)Math.Min(frameW, _gifDimensions.Width - frameX);
+            frameH = (ushort)Math.Min(frameH, _gifDimensions.Height - frameY);
+
+            currentFrame.Dimensions = new GifRect(frameX, frameY, frameW, frameH);
+
+            // Unpack interlace and lct info.
+            var packed = str.ReadByteS(tempBuf);
+            currentFrame.IsInterlaced = (packed & 0x40) != 0;
+            currentFrame.IsLocalColorTableUsed = (packed & 0x80) != 0;
+            currentFrame.LocalColorTableSize = (int)Math.Pow(2, (packed & 0x07) + 1);
+
+            if (currentFrame.IsLocalColorTableUsed)
+                currentFrame.LocalColorTable = ProcessColorTable(ref str, tempBuf, currentFrame.LocalColorTableSize);
+
+            currentFrame.LzwMinCodeSize = str.ReadByteS(tempBuf);
+            currentFrame.LzwStreamPosition = str.Position;
+
+            curFrame += 1;
+            Frames.Add(new GifFrame());
+        }
+
+        /// <summary>
+        /// Parses GIF Extension Blocks.
+        /// </summary>
+        private void ProcessExtensions(ref int curFrame, byte[] tempBuf)
+        {
+            var extType = (ExtensionType)_fileStream.ReadByteS(tempBuf);
+
+            switch (extType)
+            {
+                case ExtensionType.GraphicsControl:
+
+                    _fileStream.ReadBlock(tempBuf);
+                    var currentFrame = Frames[curFrame];
+                    var packed = tempBuf[0];
+
+                    currentFrame.FrameDisposalMethod = (FrameDisposal)((packed & 0x1c) >> 2);
+
+                    if (
+                        currentFrame.FrameDisposalMethod != FrameDisposal.Restore
+                        && currentFrame.FrameDisposalMethod != FrameDisposal.Background
+                    )
+                        currentFrame.ShouldBackup = true;
+
+                    currentFrame.HasTransparency = (packed & 1) != 0;
+
+                    currentFrame.FrameDelay = TimeSpan.FromMilliseconds(SpanToShort(tempBuf.AsSpan(1)) * 10);
+
+                    if (currentFrame.FrameDelay <= FrameDelayThreshold)
+                        currentFrame.FrameDelay = FrameDelayDefault;
+
+                    currentFrame.TransparentColorIndex = tempBuf[3];
+                    break;
+
+                case ExtensionType.Application:
+                    var blockLen = _fileStream.ReadBlock(tempBuf);
+                    var _ = tempBuf.AsSpan(0, blockLen);
+                    var blockHeader = tempBuf.AsSpan(0, NetscapeMagic.Length);
+
+                    if (blockHeader.SequenceEqual(NetscapeMagic.Span))
+                    {
+                        var count = 1;
+
+                        while (count > 0)
+                            count = _fileStream.ReadBlock(tempBuf);
+
+                        var iterationCount = SpanToShort(tempBuf.AsSpan(1));
+
+                        Header.Iterations = iterationCount;
+                    }
+                    else
+                        _fileStream.SkipBlocks(tempBuf);
+
+                    break;
+
+                default:
+                    _fileStream.SkipBlocks(tempBuf);
+                    break;
+            }
+        }
+    }
+}

Avalonia.Gif/Decoding/GifFrame.cs

@@ -0,0 +1,20 @@
+using System;
+
+namespace Avalonia.Gif.Decoding
+{
+    public class GifFrame
+    {
+        public bool HasTransparency,
+            IsInterlaced,
+            IsLocalColorTableUsed;
+        public byte TransparentColorIndex;
+        public int LzwMinCodeSize,
+            LocalColorTableSize;
+        public long LzwStreamPosition;
+        public TimeSpan FrameDelay;
+        public FrameDisposal FrameDisposalMethod;
+        public bool ShouldBackup;
+        public GifRect Dimensions;
+        public GifColor[] LocalColorTable;
+    }
+}

Avalonia.Gif/Decoding/GifHeader.cs

@@ -0,0 +1,19 @@
+// Licensed under the MIT License.
+// Copyright (C) 2018 Jumar A. Macato, All Rights Reserved.
+
+namespace Avalonia.Gif.Decoding
+{
+    public class GifHeader
+    {
+        public bool HasGlobalColorTable;
+        public int GlobalColorTableSize;
+        public ulong GlobalColorTableCacheId;
+        public int BackgroundColorIndex;
+        public long HeaderSize;
+        internal int Iterations = -1;
+        public GifRepeatBehavior IterationCount;
+        public GifRect Dimensions;
+        private GifColor[] _globarColorTable;
+        public GifColor[] GlobarColorTable;
+    }
+}

Avalonia.Gif/Decoding/GifRect.cs

@@ -0,0 +1,43 @@
+namespace Avalonia.Gif.Decoding
+{
+    public readonly struct GifRect
+    {
+        public int X { get; }
+        public int Y { get; }
+        public int Width { get; }
+        public int Height { get; }
+        public int TotalPixels { get; }
+
+        public GifRect(int x, int y, int width, int height)
+        {
+            X = x;
+            Y = y;
+            Width = width;
+            Height = height;
+            TotalPixels = width * height;
+        }
+
+        public static bool operator ==(GifRect a, GifRect b)
+        {
+            return a.X == b.X && a.Y == b.Y && a.Width == b.Width && a.Height == b.Height;
+        }
+
+        public static bool operator !=(GifRect a, GifRect b)
+        {
+            return !(a == b);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (obj == null || GetType() != obj.GetType())
+                return false;
+
+            return this == (GifRect)obj;
+        }
+
+        public override int GetHashCode()
+        {
+            return X.GetHashCode() ^ Y.GetHashCode() | Width.GetHashCode() ^ Height.GetHashCode();
+        }
+    }
+}

Avalonia.Gif/Decoding/GifRepeatBehavior.cs

@@ -0,0 +1,8 @@
+namespace Avalonia.Gif.Decoding
+{
+    public class GifRepeatBehavior
+    {
+        public bool LoopForever { get; set; }
+        public int? Count { get; set; }
+    }
+}

Avalonia.Gif/Decoding/InvalidGifStreamException.cs

@@ -0,0 +1,23 @@
+// Licensed under the MIT License.
+// Copyright (C) 2018 Jumar A. Macato, All Rights Reserved.
+
+using System;
+using System.Runtime.Serialization;
+
+namespace Avalonia.Gif.Decoding
+{
+    [Serializable]
+    public class InvalidGifStreamException : Exception
+    {
+        public InvalidGifStreamException() { }
+
+        public InvalidGifStreamException(string message)
+            : base(message) { }
+
+        public InvalidGifStreamException(string message, Exception innerException)
+            : base(message, innerException) { }
+
+        protected InvalidGifStreamException(SerializationInfo info, StreamingContext context)
+            : base(info, context) { }
+    }
+}

Avalonia.Gif/Decoding/LzwDecompressionException.cs

@@ -0,0 +1,23 @@
+// Licensed under the MIT License.
+// Copyright (C) 2018 Jumar A. Macato, All Rights Reserved.
+
+using System;
+using System.Runtime.Serialization;
+
+namespace Avalonia.Gif.Decoding
+{
+    [Serializable]
+    public class LzwDecompressionException : Exception
+    {
+        public LzwDecompressionException() { }
+
+        public LzwDecompressionException(string message)
+            : base(message) { }
+
+        public LzwDecompressionException(string message, Exception innerException)
+            : base(message, innerException) { }
+
+        protected LzwDecompressionException(SerializationInfo info, StreamingContext context)
+            : base(info, context) { }
+    }
+}

Avalonia.Gif/Extensions/StreamExtensions.cs

@@ -0,0 +1,81 @@
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Runtime.CompilerServices;
+
+namespace Avalonia.Gif.Extensions
+{
+    [DebuggerStepThrough]
+    internal static class StreamExtensions
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static ushort SpanToShort(Span<byte> b) => (ushort)(b[0] | (b[1] << 8));
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void Skip(this Stream stream, long count)
+        {
+            stream.Position += count;
+        }
+
+        /// <summary>
+        /// Read a Gif block from stream while advancing the position.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int ReadBlock(this Stream stream, byte[] tempBuf)
+        {
+            stream.Read(tempBuf, 0, 1);
+
+            var blockLength = (int)tempBuf[0];
+
+            if (blockLength > 0)
+                stream.Read(tempBuf, 0, blockLength);
+
+            // Guard against infinite loop.
+            if (stream.Position >= stream.Length)
+                throw new InvalidGifStreamException("Reach the end of the filestream without trailer block.");
+
+            return blockLength;
+        }
+
+        /// <summary>
+        /// Skips GIF blocks until it encounters an empty block.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void SkipBlocks(this Stream stream, byte[] tempBuf)
+        {
+            int blockLength;
+            do
+            {
+                stream.Read(tempBuf, 0, 1);
+
+                blockLength = tempBuf[0];
+                stream.Position += blockLength;
+
+                // Guard against infinite loop.
+                if (stream.Position >= stream.Length)
+                    throw new InvalidGifStreamException("Reach the end of the filestream without trailer block.");
+            } while (blockLength > 0);
+        }
+
+        /// <summary>
+        /// Read a <see cref="ushort"/> from stream by providing a temporary buffer.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static ushort ReadUShortS(this Stream stream, byte[] tempBuf)
+        {
+            stream.Read(tempBuf, 0, 2);
+            return SpanToShort(tempBuf);
+        }
+
+        /// <summary>
+        /// Read a <see cref="ushort"/> from stream by providing a temporary buffer.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static byte ReadByteS(this Stream stream, byte[] tempBuf)
+        {
+            stream.Read(tempBuf, 0, 1);
+            var finalVal = tempBuf[0];
+            return finalVal;
+        }
+    }
+}

Avalonia.Gif/GifImage.cs

@@ -0,0 +1,297 @@
+using System;
+using System.IO;
+using System.Numerics;
+using Avalonia;
+using Avalonia.Animation;
+using Avalonia.Controls;
+using Avalonia.Logging;
+using Avalonia.Media;
+using Avalonia.Rendering.Composition;
+using Avalonia.VisualTree;
+
+namespace Avalonia.Gif
+{
+    public class GifImage : Control
+    {
+        public static readonly StyledProperty<string> SourceUriRawProperty = AvaloniaProperty.Register<
+            GifImage,
+            string
+        >("SourceUriRaw");
+
+        public static readonly StyledProperty<Uri> SourceUriProperty = AvaloniaProperty.Register<GifImage, Uri>(
+            "SourceUri"
+        );
+
+        public static readonly StyledProperty<Stream> SourceStreamProperty = AvaloniaProperty.Register<
+            GifImage,
+            Stream
+        >("SourceStream");
+
+        public static readonly StyledProperty<IterationCount> IterationCountProperty = AvaloniaProperty.Register<
+            GifImage,
+            IterationCount
+        >("IterationCount", IterationCount.Infinite);
+
+        private IGifInstance? _gifInstance;
+
+        public static readonly StyledProperty<StretchDirection> StretchDirectionProperty = AvaloniaProperty.Register<
+            GifImage,
+            StretchDirection
+        >("StretchDirection");
+
+        public static readonly StyledProperty<Stretch> StretchProperty = AvaloniaProperty.Register<GifImage, Stretch>(
+            "Stretch"
+        );
+
+        private CompositionCustomVisual? _customVisual;
+
+        private object? _initialSource = null;
+
+        protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs change)
+        {
+            switch (change.Property.Name)
+            {
+                case nameof(SourceUriRaw):
+                case nameof(SourceUri):
+                case nameof(SourceStream):
+                    SourceChanged(change);
+                    break;
+                case nameof(Stretch):
+                case nameof(StretchDirection):
+                    InvalidateArrange();
+                    InvalidateMeasure();
+                    Update();
+                    break;
+                case nameof(IterationCount):
+                    IterationCountChanged(change);
+                    break;
+                case nameof(Bounds):
+                    Update();
+                    break;
+            }
+
+            base.OnPropertyChanged(change);
+        }
+
+        public string SourceUriRaw
+        {
+            get => GetValue(SourceUriRawProperty);
+            set => SetValue(SourceUriRawProperty, value);
+        }
+
+        public Uri SourceUri
+        {
+            get => GetValue(SourceUriProperty);
+            set => SetValue(SourceUriProperty, value);
+        }
+
+        public Stream SourceStream
+        {
+            get => GetValue(SourceStreamProperty);
+            set => SetValue(SourceStreamProperty, value);
+        }
+
+        public IterationCount IterationCount
+        {
+            get => GetValue(IterationCountProperty);
+            set => SetValue(IterationCountProperty, value);
+        }
+
+        public StretchDirection StretchDirection
+        {
+            get => GetValue(StretchDirectionProperty);
+            set => SetValue(StretchDirectionProperty, value);
+        }
+
+        public Stretch Stretch
+        {
+            get => GetValue(StretchProperty);
+            set => SetValue(StretchProperty, value);
+        }
+
+        private static void IterationCountChanged(AvaloniaPropertyChangedEventArgs e)
+        {
+            var image = e.Sender as GifImage;
+            if (image is null || e.NewValue is not IterationCount iterationCount)
+                return;
+
+            image.IterationCount = iterationCount;
+        }
+
+        protected override void OnAttachedToVisualTree(VisualTreeAttachmentEventArgs e)
+        {
+            var compositor = ElementComposition.GetElementVisual(this)?.Compositor;
+            if (compositor == null || _customVisual?.Compositor == compositor)
+                return;
+            _customVisual = compositor.CreateCustomVisual(new CustomVisualHandler());
+            ElementComposition.SetElementChildVisual(this, _customVisual);
+            _customVisual.SendHandlerMessage(CustomVisualHandler.StartMessage);
+
+            if (_initialSource is not null)
+            {
+                UpdateGifInstance(_initialSource);
+                _initialSource = null;
+            }
+
+            Update();
+            base.OnAttachedToVisualTree(e);
+        }
+
+        private void Update()
+        {
+            if (_customVisual is null || _gifInstance is null)
+                return;
+
+            var dpi = this.GetVisualRoot()?.RenderScaling ?? 1.0;
+            var sourceSize = _gifInstance.GifPixelSize.ToSize(dpi);
+            var viewPort = new Rect(Bounds.Size);
+
+            var scale = Stretch.CalculateScaling(Bounds.Size, sourceSize, StretchDirection);
+            var scaledSize = sourceSize * scale;
+            var destRect = viewPort.CenterRect(new Rect(scaledSize)).Intersect(viewPort);
+
+            if (Stretch == Stretch.None)
+            {
+                _customVisual.Size = new Vector2((float)sourceSize.Width, (float)sourceSize.Height);
+            }
+            else
+            {
+                _customVisual.Size = new Vector2((float)destRect.Size.Width, (float)destRect.Size.Height);
+            }
+
+            _customVisual.Offset = new Vector3((float)destRect.Position.X, (float)destRect.Position.Y, 0);
+        }
+
+        private class CustomVisualHandler : CompositionCustomVisualHandler
+        {
+            private TimeSpan _animationElapsed;
+            private TimeSpan? _lastServerTime;
+            private IGifInstance? _currentInstance;
+            private bool _running;
+
+            public static readonly object StopMessage = new(),
+                StartMessage = new();
+
+            public override void OnMessage(object message)
+            {
+                if (message == StartMessage)
+                {
+                    _running = true;
+                    _lastServerTime = null;
+                    RegisterForNextAnimationFrameUpdate();
+                }
+                else if (message == StopMessage)
+                {
+                    _running = false;
+                }
+                else if (message is IGifInstance instance)
+                {
+                    _currentInstance?.Dispose();
+                    _currentInstance = instance;
+                }
+            }
+
+            public override void OnAnimationFrameUpdate()
+            {
+                if (!_running)
+                    return;
+                Invalidate();
+                RegisterForNextAnimationFrameUpdate();
+            }
+
+            public override void OnRender(ImmediateDrawingContext drawingContext)
+            {
+                if (_running)
+                {
+                    if (_lastServerTime.HasValue)
+                        _animationElapsed += (CompositionNow - _lastServerTime.Value);
+                    _lastServerTime = CompositionNow;
+                }
+
+                try
+                {
+                    if (_currentInstance is null || _currentInstance.IsDisposed)
+                        return;
+
+                    var bitmap = _currentInstance.ProcessFrameTime(_animationElapsed);
+                    if (bitmap is not null)
+                    {
+                        drawingContext.DrawBitmap(
+                            bitmap,
+                            new Rect(_currentInstance.GifPixelSize.ToSize(1)),
+                            GetRenderBounds()
+                        );
+                    }
+                }
+                catch (Exception e)
+                {
+                    Logger.Sink?.Log(LogEventLevel.Error, "GifImage Renderer ", this, e.ToString());
+                }
+            }
+        }
+
+        /// <summary>
+        /// Measures the control.
+        /// </summary>
+        /// <param name="availableSize">The available size.</param>
+        /// <returns>The desired size of the control.</returns>
+        protected override Size MeasureOverride(Size availableSize)
+        {
+            var result = new Size();
+            var scaling = this.GetVisualRoot()?.RenderScaling ?? 1.0;
+            if (_gifInstance != null)
+            {
+                result = Stretch.CalculateSize(
+                    availableSize,
+                    _gifInstance.GifPixelSize.ToSize(scaling),
+                    StretchDirection
+                );
+            }
+
+            return result;
+        }
+
+        /// <inheritdoc/>
+        protected override Size ArrangeOverride(Size finalSize)
+        {
+            if (_gifInstance is null)
+                return new Size();
+            var scaling = this.GetVisualRoot()?.RenderScaling ?? 1.0;
+            var sourceSize = _gifInstance.GifPixelSize.ToSize(scaling);
+            var result = Stretch.CalculateSize(finalSize, sourceSize);
+            return result;
+        }
+
+        private void SourceChanged(AvaloniaPropertyChangedEventArgs e)
+        {
+            if (
+                e.NewValue is null
+                || (e.NewValue is string value && !Uri.IsWellFormedUriString(value, UriKind.Absolute))
+            )
+            {
+                return;
+            }
+
+            if (_customVisual is null)
+            {
+                _initialSource = e.NewValue;
+                return;
+            }
+
+            UpdateGifInstance(e.NewValue);
+
+            InvalidateArrange();
+            InvalidateMeasure();
+            Update();
+        }
+
+        private void UpdateGifInstance(object source)
+        {
+            _gifInstance?.Dispose();
+            _gifInstance = new WebpInstance(source);
+            // _gifInstance = new GifInstance(source);
+            _gifInstance.IterationCount = IterationCount;
+            _customVisual?.SendHandlerMessage(_gifInstance);
+        }
+    }
+}

Avalonia.Gif/GifInstance.cs

@@ -0,0 +1,147 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using Avalonia;
+using Avalonia.Animation;
+using Avalonia.Gif.Decoding;
+using Avalonia.Media.Imaging;
+using Avalonia.Platform;
+
+namespace Avalonia.Gif
+{
+    public class GifInstance : IGifInstance
+    {
+        public IterationCount IterationCount { get; set; }
+        public bool AutoStart { get; private set; } = true;
+        private readonly GifDecoder _gifDecoder;
+        private readonly WriteableBitmap? _targetBitmap;
+        private TimeSpan _totalTime;
+        private readonly List<TimeSpan> _frameTimes;
+        private uint _iterationCount;
+        private int _currentFrameIndex;
+        private readonly List<ulong> _colorTableIdList;
+
+        public CancellationTokenSource CurrentCts { get; }
+
+        internal GifInstance(object newValue)
+            : this(
+                newValue switch
+                {
+                    Stream s => s,
+                    Uri u => GetStreamFromUri(u),
+                    string str => GetStreamFromString(str),
+                    _ => throw new InvalidDataException("Unsupported source object")
+                }
+            ) { }
+
+        public GifInstance(string uri)
+            : this(GetStreamFromString(uri)) { }
+
+        public GifInstance(Uri uri)
+            : this(GetStreamFromUri(uri)) { }
+
+        public GifInstance(Stream currentStream)
+        {
+            if (!currentStream.CanSeek)
+                throw new InvalidDataException("The provided stream is not seekable.");
+
+            if (!currentStream.CanRead)
+                throw new InvalidOperationException("Can't read the stream provided.");
+
+            currentStream.Seek(0, SeekOrigin.Begin);
+
+            CurrentCts = new CancellationTokenSource();
+
+            _gifDecoder = new GifDecoder(currentStream, CurrentCts.Token);
+            var pixSize = new PixelSize(_gifDecoder.Header.Dimensions.Width, _gifDecoder.Header.Dimensions.Height);
+
+            _targetBitmap = new WriteableBitmap(pixSize, new Vector(96, 96), PixelFormat.Bgra8888, AlphaFormat.Opaque);
+            GifPixelSize = pixSize;
+
+            _totalTime = TimeSpan.Zero;
+
+            _frameTimes = _gifDecoder
+                .Frames
+                .Select(frame =>
+                {
+                    _totalTime = _totalTime.Add(frame.FrameDelay);
+                    return _totalTime;
+                })
+                .ToList();
+
+            _gifDecoder.RenderFrame(0, _targetBitmap);
+        }
+
+        private static Stream GetStreamFromString(string str)
+        {
+            if (!Uri.TryCreate(str, UriKind.RelativeOrAbsolute, out var res))
+            {
+                throw new InvalidCastException("The string provided can't be converted to URI.");
+            }
+
+            return GetStreamFromUri(res);
+        }
+
+        private static Stream GetStreamFromUri(Uri uri)
+        {
+            var uriString = uri.OriginalString.Trim();
+
+            if (!uriString.StartsWith("resm") && !uriString.StartsWith("avares"))
+            {
+                return new FileStream(uriString, FileMode.Open, FileAccess.Read);
+            }
+
+            return AssetLoader.Open(uri);
+        }
+
+        public int GifFrameCount => _frameTimes.Count;
+
+        public PixelSize GifPixelSize { get; }
+
+        public void Dispose()
+        {
+            IsDisposed = true;
+            CurrentCts.Cancel();
+            _targetBitmap?.Dispose();
+        }
+
+        public bool IsDisposed { get; private set; }
+
+        public WriteableBitmap? ProcessFrameTime(TimeSpan stopwatchElapsed)
+        {
+            if (!IterationCount.IsInfinite && _iterationCount > IterationCount.Value)
+            {
+                return null;
+            }
+
+            if (CurrentCts.IsCancellationRequested || _targetBitmap is null)
+            {
+                return null;
+            }
+
+            var elapsedTicks = stopwatchElapsed.Ticks;
+            var timeModulus = TimeSpan.FromTicks(elapsedTicks % _totalTime.Ticks);
+            var targetFrame = _frameTimes.FirstOrDefault(x => timeModulus < x);
+            var currentFrame = _frameTimes.IndexOf(targetFrame);
+            if (currentFrame == -1)
+                currentFrame = 0;
+
+            if (_currentFrameIndex == currentFrame)
+                return _targetBitmap;
+
+            _iterationCount = (uint)(elapsedTicks / _totalTime.Ticks);
+
+            return ProcessFrameIndex(currentFrame);
+        }
+
+        internal WriteableBitmap ProcessFrameIndex(int frameIndex)
+        {
+            _gifDecoder.RenderFrame(frameIndex, _targetBitmap);
+            _currentFrameIndex = frameIndex;
+
+            return _targetBitmap;
+        }
+    }
+}

Avalonia.Gif/IGifInstance.cs

@@ -0,0 +1,15 @@
+using Avalonia.Animation;
+using Avalonia.Media.Imaging;
+
+namespace Avalonia.Gif;
+
+public interface IGifInstance : IDisposable
+{
+    IterationCount IterationCount { get; set; }
+    bool AutoStart { get; }
+    CancellationTokenSource CurrentCts { get; }
+    int GifFrameCount { get; }
+    PixelSize GifPixelSize { get; }
+    bool IsDisposed { get; }
+    WriteableBitmap? ProcessFrameTime(TimeSpan stopwatchElapsed);
+}

Avalonia.Gif/InvalidGifStreamException.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Runtime.Serialization;
+
+namespace Avalonia.Gif
+{
+    [Serializable]
+    internal class InvalidGifStreamException : Exception
+    {
+        public InvalidGifStreamException() { }
+
+        public InvalidGifStreamException(string message)
+            : base(message) { }
+
+        public InvalidGifStreamException(string message, Exception innerException)
+            : base(message, innerException) { }
+
+        protected InvalidGifStreamException(SerializationInfo info, StreamingContext context)
+            : base(info, context) { }
+    }
+}

Avalonia.Gif/WebpInstance.cs

@@ -0,0 +1,180 @@
+using Avalonia.Animation;
+using Avalonia.Media.Imaging;
+using Avalonia.Platform;
+using SkiaSharp;
+
+namespace Avalonia.Gif;
+
+public class WebpInstance : IGifInstance
+{
+    public IterationCount IterationCount { get; set; }
+    public bool AutoStart { get; private set; } = true;
+
+    private readonly WriteableBitmap? _targetBitmap;
+    private TimeSpan _totalTime;
+    private readonly List<TimeSpan> _frameTimes;
+    private uint _iterationCount;
+    private int _currentFrameIndex;
+
+    private SKCodec? _codec;
+
+    public CancellationTokenSource CurrentCts { get; }
+
+    internal WebpInstance(object newValue)
+        : this(
+            newValue switch
+            {
+                Stream s => s,
+                Uri u => GetStreamFromUri(u),
+                string str => GetStreamFromString(str),
+                _ => throw new InvalidDataException("Unsupported source object")
+            }
+        ) { }
+
+    public WebpInstance(string uri)
+        : this(GetStreamFromString(uri)) { }
+
+    public WebpInstance(Uri uri)
+        : this(GetStreamFromUri(uri)) { }
+
+    public WebpInstance(Stream currentStream)
+    {
+        if (!currentStream.CanSeek)
+            throw new InvalidDataException("The provided stream is not seekable.");
+
+        if (!currentStream.CanRead)
+            throw new InvalidOperationException("Can't read the stream provided.");
+
+        currentStream.Seek(0, SeekOrigin.Begin);
+
+        CurrentCts = new CancellationTokenSource();
+
+        var managedStream = new SKManagedStream(currentStream);
+        _codec = SKCodec.Create(managedStream);
+
+        var pixSize = new PixelSize(_codec.Info.Width, _codec.Info.Height);
+
+        _targetBitmap = new WriteableBitmap(pixSize, new Vector(96, 96), PixelFormat.Bgra8888, AlphaFormat.Opaque);
+        GifPixelSize = pixSize;
+
+        _totalTime = TimeSpan.Zero;
+
+        _frameTimes = _codec
+            .FrameInfo
+            .Select(frame =>
+            {
+                _totalTime = _totalTime.Add(TimeSpan.FromMilliseconds(frame.Duration));
+                return _totalTime;
+            })
+            .ToList();
+
+        RenderFrame(_codec, _targetBitmap, 0);
+    }
+
+    private static void RenderFrame(SKCodec codec, WriteableBitmap targetBitmap, int index)
+    {
+        codec.GetFrameInfo(index, out var frameInfo);
+
+        var info = new SKImageInfo(codec.Info.Width, codec.Info.Height);
+        var decodeInfo = info.WithAlphaType(frameInfo.AlphaType);
+
+        using var frameBuffer = targetBitmap.Lock();
+
+        var result = codec.GetPixels(decodeInfo, frameBuffer.Address, new SKCodecOptions(index));
+
+        if (result != SKCodecResult.Success)
+            throw new InvalidDataException($"Could not decode frame {index} of {codec.FrameCount}.");
+    }
+
+    private static void RenderFrame(SKCodec codec, WriteableBitmap targetBitmap, int index, int priorIndex)
+    {
+        codec.GetFrameInfo(index, out var frameInfo);
+
+        var info = new SKImageInfo(codec.Info.Width, codec.Info.Height);
+        var decodeInfo = info.WithAlphaType(frameInfo.AlphaType);
+
+        using var frameBuffer = targetBitmap.Lock();
+
+        var result = codec.GetPixels(decodeInfo, frameBuffer.Address, new SKCodecOptions(index, priorIndex));
+
+        if (result != SKCodecResult.Success)
+            throw new InvalidDataException($"Could not decode frame {index} of {codec.FrameCount}.");
+    }
+
+    private static Stream GetStreamFromString(string str)
+    {
+        if (!Uri.TryCreate(str, UriKind.RelativeOrAbsolute, out var res))
+        {
+            throw new InvalidCastException("The string provided can't be converted to URI.");
+        }
+
+        return GetStreamFromUri(res);
+    }
+
+    private static Stream GetStreamFromUri(Uri uri)
+    {
+        var uriString = uri.OriginalString.Trim();
+
+        if (!uriString.StartsWith("resm") && !uriString.StartsWith("avares"))
+        {
+            return new FileStream(uriString, FileMode.Open, FileAccess.Read);
+        }
+
+        return AssetLoader.Open(uri);
+    }
+
+    public int GifFrameCount => _frameTimes.Count;
+
+    public PixelSize GifPixelSize { get; }
+
+    public void Dispose()
+    {
+        IsDisposed = true;
+        CurrentCts.Cancel();
+        _targetBitmap?.Dispose();
+        _codec?.Dispose();
+    }
+
+    public bool IsDisposed { get; private set; }
+
+    public WriteableBitmap? ProcessFrameTime(TimeSpan stopwatchElapsed)
+    {
+        if (!IterationCount.IsInfinite && _iterationCount > IterationCount.Value)
+        {
+            return null;
+        }
+
+        if (CurrentCts.IsCancellationRequested || _targetBitmap is null)
+        {
+            return null;
+        }
+
+        var elapsedTicks = stopwatchElapsed.Ticks;
+        var timeModulus = TimeSpan.FromTicks(elapsedTicks % _totalTime.Ticks);
+        var targetFrame = _frameTimes.FirstOrDefault(x => timeModulus < x);
+        var currentFrame = _frameTimes.IndexOf(targetFrame);
+        if (currentFrame == -1)
+            currentFrame = 0;
+
+        if (_currentFrameIndex == currentFrame)
+            return _targetBitmap;
+
+        _iterationCount = (uint)(elapsedTicks / _totalTime.Ticks);
+
+        return ProcessFrameIndex(currentFrame);
+    }
+
+    internal WriteableBitmap ProcessFrameIndex(int frameIndex)
+    {
+        if (_codec is null)
+            throw new InvalidOperationException("The codec is null.");
+
+        if (_targetBitmap is null)
+            throw new InvalidOperationException("The target bitmap is null.");
+
+        RenderFrame(_codec, _targetBitmap, frameIndex, _currentFrameIndex);
+        _currentFrameIndex = frameIndex;
+
+        return _targetBitmap;
+    }
+}

CHANGELOG.md

@@ -5,12 +5,28 @@ All notable changes to Stability Matrix will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning 2.0](https://semver.org/spec/v2.0.0.html).
 
-## v2.7.7
+## v2.8.0-dev.3
 ### Added
 - Added ComfyUI launch argument configs: Cross Attention Method, Force Floating Point Precision, VAE Precision
 ### Changed
 - Python Packages install dialog now allows entering multiple arguments or option flags
 
+## v2.8.0-dev.2
+### Added
+#### Inference
+- Added Image to Video project type
+#### Output Browser
+- Added support for webp files
+- Added "Send to Image to Image" and "Send to Image to Video" options to the context menu
+### Changed
+- Changed how settings file is written to disk to reduce potential data loss risk
+
+## v2.8.0-dev.1
+### Added
+#### Inference
+- Added image and model details in model selection boxes
+- Added CLIP Skip setting, toggleable from the model settings button
+
 ## v2.7.6
 ### Added
 - Added SDXL Turbo and Stable Video Diffusion to the Hugging Face tab

StabilityMatrix.Avalonia.Diagnostics/StabilityMatrix.Avalonia.Diagnostics.csproj

@@ -21,6 +21,7 @@
     <ItemGroup>
       <PackageReference Include="Avalonia" Version="11.0.5" />
       <PackageReference Include="Avalonia.Controls.DataGrid" Version="11.0.5" />
+      <PackageReference Include="DotNet.Bundle" Version="0.9.13" />
       <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="7.0.0" />
       <PackageReference Include="Microsoft.Extensions.Hosting" Version="7.0.1" />
       <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="7.0.1" />

StabilityMatrix.Avalonia/App.axaml

@@ -4,6 +4,7 @@
              xmlns:local="using:StabilityMatrix.Avalonia"
              xmlns:idcr="using:Dock.Avalonia.Controls.Recycling"
              xmlns:styling="clr-namespace:FluentAvalonia.Styling;assembly=FluentAvalonia"
+             Name="Stability Matrix"
              RequestedThemeVariant="Dark">
              <!-- "Default" ThemeVariant follows system theme variant. "Dark" or "Light" are other available options. -->
 
@@ -23,6 +24,7 @@
                  <ResourceInclude Source="Controls/Scroll/BetterScrollViewer.axaml"/>
                  <ResourceInclude Source="Styles/ControlThemes/HyperlinkIconButtonStyles.axaml"/>
                  <ResourceInclude Source="Styles/ControlThemes/ListBoxStyles.axaml"/>
+                 <ResourceInclude Source="Styles/ControlThemes/BetterComboBoxStyles.axaml"/>
                  <ResourceInclude Source="Styles/ListBoxStyles.axaml"/>
                  <ResourceInclude Source="Styles/FAComboBoxStyles.axaml"/>
                  <ResourceInclude Source="Controls/Inference/ImageFolderCard.axaml"/>
@@ -58,6 +60,8 @@
         <StyleInclude Source="Controls/SelectableImageCard/SelectableImageButton.axaml"/>
         <StyleInclude Source="Controls/SettingsAccountLinkExpander.axaml"/>
         <StyleInclude Source="Controls/StarsRating.axaml"/>
+        <StyleInclude Source="Controls/VideoGenerationSettingsCard.axaml"/>
+        <StyleInclude Source="Controls/VideoOutputSettingsCard.axaml"/>
         <StyleInclude Source="Controls/Inference/StackCard.axaml"/>
         <StyleInclude Source="Controls/Inference/StackEditableCard.axaml"/>
         <StyleInclude Source="Controls/Inference/StackExpander.axaml"/>

StabilityMatrix.Avalonia/App.axaml.cs

@@ -80,7 +80,8 @@ public sealed class App : Application
 
     public static TopLevel TopLevel => TopLevel.GetTopLevel(VisualRoot)!;
 
-    internal static bool IsHeadlessMode => TopLevel.TryGetPlatformHandle()?.HandleDescriptor is null or "STUB";
+    internal static bool IsHeadlessMode =>
+        TopLevel.TryGetPlatformHandle()?.HandleDescriptor is null or "STUB";
 
     [NotNull]
     public static IStorageProvider? StorageProvider { get; internal set; }
@@ -117,8 +118,7 @@ public sealed class App : Application
     {
         // Remove DataAnnotations validation plugin since we're using INotifyDataErrorInfo from MvvmToolkit
         var dataValidationPluginsToRemove = BindingPlugins
-            .DataValidators
-            .OfType<DataAnnotationsValidationPlugin>()
+            .DataValidators.OfType<DataAnnotationsValidationPlugin>()
             .ToArray();
 
         foreach (var plugin in dataValidationPluginsToRemove)
@@ -161,10 +161,7 @@ public sealed class App : Application
 
                 DesktopLifetime.MainWindow = setupWindow;
 
-                setupWindow
-                    .ShowAsyncCts
-                    .Token
-                    .Register(() =>
+                setupWindow.ShowAsyncCts.Token.Register(() =>
                 {
                     if (setupWindow.Result == ContentDialogResult.Primary)
                     {
@@ -297,7 +294,9 @@ public sealed class App : Application
             var serviceManager = new ServiceManager<ViewModelBase>();
 
             var serviceManagedTypes = exportedTypes
-                .Select(t => new { t, attributes = t.GetCustomAttributes(typeof(ManagedServiceAttribute), true) })
+                .Select(
+                    t => new { t, attributes = t.GetCustomAttributes(typeof(ManagedServiceAttribute), true) }
+                )
                 .Where(t1 => t1.attributes is { Length: > 0 })
                 .Select(t1 => t1.t)
                 .ToList();
@@ -322,8 +321,7 @@ public sealed class App : Application
         services.AddMessagePipeNamedPipeInterprocess("StabilityMatrix");
 
         var exportedTypes = AppDomain
-            .CurrentDomain
-            .GetAssemblies()
+            .CurrentDomain.GetAssemblies()
             .Where(a => a.FullName?.StartsWith("StabilityMatrix") == true)
             .SelectMany(a => a.GetExportedTypes())
             .ToArray();
@@ -332,7 +330,8 @@ public sealed class App : Application
             .Select(t => new { t, attributes = t.GetCustomAttributes(typeof(TransientAttribute), false) })
             .Where(
                 t1 =>
-                    t1.attributes is { Length: > 0 } && !t1.t.Name.Contains("Mock", StringComparison.OrdinalIgnoreCase)
+                    t1.attributes is { Length: > 0 }
+                    && !t1.t.Name.Contains("Mock", StringComparison.OrdinalIgnoreCase)
             )
             .Select(t1 => new { Type = t1.t, Attribute = (TransientAttribute)t1.attributes[0] });
 
@@ -352,9 +351,12 @@ public sealed class App : Application
             .Select(t => new { t, attributes = t.GetCustomAttributes(typeof(SingletonAttribute), false) })
             .Where(
                 t1 =>
-                    t1.attributes is { Length: > 0 } && !t1.t.Name.Contains("Mock", StringComparison.OrdinalIgnoreCase)
+                    t1.attributes is { Length: > 0 }
+                    && !t1.t.Name.Contains("Mock", StringComparison.OrdinalIgnoreCase)
             )
-            .Select(t1 => new { Type = t1.t, Attributes = t1.attributes.Cast<SingletonAttribute>().ToArray() });
+            .Select(
+                t1 => new { Type = t1.t, Attributes = t1.attributes.Cast<SingletonAttribute>().ToArray() }
+            );
 
         foreach (var typePair in singletonTypes)
         {
@@ -386,7 +388,9 @@ public sealed class App : Application
 
         // Rich presence
         services.AddSingleton<IDiscordRichPresenceService, DiscordRichPresenceService>();
-        services.AddSingleton<IDisposable>(provider => provider.GetRequiredService<IDiscordRichPresenceService>());
+        services.AddSingleton<IDisposable>(
+            provider => provider.GetRequiredService<IDiscordRichPresenceService>()
+        );
 
         Config = new ConfigurationBuilder()
             .SetBasePath(Directory.GetCurrentDirectory())
@@ -557,7 +561,11 @@ public sealed class App : Application
 #if DEBUG
             builder.AddNLog(
                 ConfigureLogging(),
-                new NLogProviderOptions { IgnoreEmptyEventId = false, CaptureEventId = EventIdCaptureType.Legacy }
+                new NLogProviderOptions
+                {
+                    IgnoreEmptyEventId = false,
+                    CaptureEventId = EventIdCaptureType.Legacy
+                }
             );
 #else
             builder.AddNLog(ConfigureLogging());
@@ -591,8 +599,6 @@ public sealed class App : Application
         if (e.Cancel)
             return;
 
-        var mainWindow = (MainWindow)sender!;
-
         // Show confirmation if package running
         var launchPageViewModel = Services.GetRequiredService<LaunchPageViewModel>();
         launchPageViewModel.OnMainWindowClosing(e);
@@ -602,10 +608,11 @@ public sealed class App : Application
 
         // Check if we need to dispose IAsyncDisposables
         if (
-            !isAsyncDisposeComplete
-            && Services.GetServices<IAsyncDisposable>().ToList() is { Count: > 0 } asyncDisposables
+            isAsyncDisposeComplete
+            || Services.GetServices<IAsyncDisposable>().ToList() is not { Count: > 0 } asyncDisposables
         )
-        {
+            return;
+
         // Cancel shutdown for now
         e.Cancel = true;
         isAsyncDisposeComplete = true;
@@ -633,35 +640,6 @@ public sealed class App : Application
                 Dispatcher.UIThread.Invoke(() => Shutdown());
             })
             .SafeFireAndForget();
-
-            return;
-        }
-
-        OnMainWindowClosingTerminal(mainWindow);
-    }
-
-    /// <summary>
-    /// Called at the end of <see cref="OnMainWindowClosing"/> before the main window is closed.
-    /// </summary>
-    private static void OnMainWindowClosingTerminal(Window sender)
-    {
-        var settingsManager = Services.GetRequiredService<ISettingsManager>();
-
-        // Save window position
-        var validWindowPosition = sender.Screens.All.Any(screen => screen.Bounds.Contains(sender.Position));
-
-        settingsManager.Transaction(
-            s =>
-            {
-                s.WindowSettings = new WindowSettings(
-                    sender.Width,
-                    sender.Height,
-                    validWindowPosition ? sender.Position.X : 0,
-                    validWindowPosition ? sender.Position.Y : 0
-                );
-            },
-            ignoreMissingLibraryDir: true
-        );
     }
 
     private static void OnExit(object? sender, ControlledApplicationLifetimeExitEventArgs args)
@@ -714,10 +692,12 @@ public sealed class App : Application
                 .WriteTo(
                     new FileTarget
                     {
-                        Layout = "${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}",
+                        Layout =
+                            "${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}",
                         ArchiveOldFileOnStartup = true,
                         FileName = "${specialfolder:folder=ApplicationData}/StabilityMatrix/app.log",
-                        ArchiveFileName = "${specialfolder:folder=ApplicationData}/StabilityMatrix/app.{#}.log",
+                        ArchiveFileName =
+                            "${specialfolder:folder=ApplicationData}/StabilityMatrix/app.{#}.log",
                         ArchiveNumbering = ArchiveNumberingMode.Rolling,
                         MaxArchiveFiles = 2
                     }
@@ -730,7 +710,9 @@ public sealed class App : Application
             builder.ForLogger("Microsoft.Extensions.Http.*").WriteToNil(NLog.LogLevel.Warn);
 
             // Disable console trace logging by default
-            builder.ForLogger("StabilityMatrix.Avalonia.ViewModels.ConsoleViewModel").WriteToNil(NLog.LogLevel.Debug);
+            builder
+                .ForLogger("StabilityMatrix.Avalonia.ViewModels.ConsoleViewModel")
+                .WriteToNil(NLog.LogLevel.Debug);
 
             // Disable LoadableViewModelBase trace logging by default
             builder
@@ -751,9 +733,7 @@ public sealed class App : Application
         // Sentry
         if (SentrySdk.IsEnabled)
         {
-            LogManager
-                .Configuration
-                .AddSentry(o =>
+            LogManager.Configuration.AddSentry(o =>
             {
                 o.InitializeSdk = false;
                 o.Layout = "${message}";
@@ -803,12 +783,14 @@ public sealed class App : Application
             results.Add(ms);
         }
 
-        Dispatcher
-            .UIThread
-            .InvokeAsync(async () =>
+        Dispatcher.UIThread.InvokeAsync(async () =>
         {
             var dest = await StorageProvider.SaveFilePickerAsync(
-                    new FilePickerSaveOptions() { SuggestedFileName = "screenshot.png", ShowOverwritePrompt = true }
+                new FilePickerSaveOptions()
+                {
+                    SuggestedFileName = "screenshot.png",
+                    ShowOverwritePrompt = true
+                }
             );
 
             if (dest?.TryGetLocalPath() is { } localPath)

StabilityMatrix.Avalonia/Controls/AdvancedImageBoxView.axaml

@@ -8,14 +8,24 @@
     xmlns:mocks="clr-namespace:StabilityMatrix.Avalonia.DesignData"
     xmlns:models="clr-namespace:StabilityMatrix.Avalonia.Models"
     xmlns:ui="clr-namespace:FluentAvalonia.UI.Controls;assembly=FluentAvalonia"
+    xmlns:gif="clr-namespace:Avalonia.Gif;assembly=Avalonia.Gif"
     d:DataContext="{x:Static mocks:DesignData.SampleImageSource}"
     d:DesignHeight="450"
     d:DesignWidth="800"
     x:DataType="models:ImageSource"
     mc:Ignorable="d">
     <Grid>
+        <ContentPresenter Content="{Binding}">
+            <ContentPresenter.ContentTemplate>
+                <controls:DataTemplateSelector x:TypeArguments="models:ImageSourceTemplateType">
+                    <DataTemplate x:Key="{x:Static models:ImageSourceTemplateType.WebpAnimation}" DataType="models:ImageSource">
+                        <gif:GifImage
+                            Stretch="Uniform"
+                            SourceUri="{Binding LocalFile.FullPath}"/>
+                    </DataTemplate>
+                    
+                    <DataTemplate x:Key="{x:Static models:ImageSourceTemplateType.Image}" DataType="models:ImageSource">
                         <controls:AdvancedImageBox
-            Name="ImageBox"
                             CornerRadius="4"
                             Image="{Binding BitmapAsync^}"
                             SizeMode="Fit">
@@ -23,15 +33,18 @@
                                 <ui:FAMenuFlyout>
                                     <ui:MenuFlyoutItem
                                         x:Name="CopyMenuItem"
-                        CommandParameter="{Binding #ImageBox.Image}"
+                                        CommandParameter="{Binding $parent[controls:AdvancedImageBox].Image}"
                                         HotKey="Ctrl+C"
                                         IconSource="Copy"
-                        IsEnabled="{OnPlatform Windows=True,
-                                               Default=False}"
+                                        IsEnabled="{OnPlatform Windows=True, Default=False}"
                                         Text="Copy" />
                                 </ui:FAMenuFlyout>
                             </controls:AdvancedImageBox.ContextFlyout>
                         </controls:AdvancedImageBox>
+                    </DataTemplate>
+                </controls:DataTemplateSelector>
+            </ContentPresenter.ContentTemplate>
+        </ContentPresenter>
 
         <!-- Label pill card -->
         <Border

StabilityMatrix.Avalonia/Controls/AdvancedImageBoxView.axaml.cs

@@ -21,13 +21,16 @@ public partial class AdvancedImageBoxView : UserControl
     {
         base.OnApplyTemplate(e);
 
-        var copyMenuItem = this.FindControl<MenuFlyoutItem>("CopyMenuItem")!;
+        if (this.FindControl<MenuFlyoutItem>("CopyMenuItem") is { } copyMenuItem)
+        {
             copyMenuItem.Command = new AsyncRelayCommand<Bitmap?>(FlyoutCopy);
         }
+    }
 
     private static async Task FlyoutCopy(Bitmap? image)
     {
-        if (image is null || !Compat.IsWindows) return;
+        if (image is null || !Compat.IsWindows)
+            return;
 
         await Task.Run(() =>
         {

StabilityMatrix.Avalonia/Controls/BetterComboBox.cs

@@ -0,0 +1,41 @@
+using System;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Controls.Primitives;
+using Avalonia.Controls.Templates;
+
+namespace StabilityMatrix.Avalonia.Controls;
+
+public class BetterComboBox : ComboBox
+{
+    // protected override Type StyleKeyOverride { get; } = typeof(CheckBox);
+
+    public static readonly DirectProperty<BetterComboBox, IDataTemplate?> SelectionBoxItemTemplateProperty =
+        AvaloniaProperty.RegisterDirect<BetterComboBox, IDataTemplate?>(
+            nameof(SelectionBoxItemTemplate),
+            v => v.SelectionBoxItemTemplate,
+            (x, v) => x.SelectionBoxItemTemplate = v
+        );
+
+    private IDataTemplate? _selectionBoxItemTemplate;
+
+    public IDataTemplate? SelectionBoxItemTemplate
+    {
+        get => _selectionBoxItemTemplate;
+        private set => SetAndRaise(SelectionBoxItemTemplateProperty, ref _selectionBoxItemTemplate, value);
+    }
+
+    /// <inheritdoc />
+    protected override void OnApplyTemplate(TemplateAppliedEventArgs e)
+    {
+        base.OnApplyTemplate(e);
+
+        if (e.NameScope.Find<ContentControl>("ContentPresenter") is { } contentPresenter)
+        {
+            if (SelectionBoxItemTemplate is { } template)
+            {
+                contentPresenter.ContentTemplate = template;
+            }
+        }
+    }
+}

StabilityMatrix.Avalonia/Controls/DataTemplateSelector.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Collections.Generic;
+using Avalonia.Controls;
+using Avalonia.Controls.Templates;
+using Avalonia.Metadata;
+using JetBrains.Annotations;
+using StabilityMatrix.Avalonia.Models;
+
+namespace StabilityMatrix.Avalonia.Controls;
+
+/// <summary>
+/// Selector for objects implementing <see cref="ITemplateKey{T}"/>
+/// </summary>
+[PublicAPI]
+public class DataTemplateSelector<TKey> : IDataTemplate
+    where TKey : notnull
+{
+    /// <summary>
+    /// Key that is used when no other key matches
+    /// </summary>
+    public TKey? DefaultKey { get; set; }
+
+    [Content]
+    public Dictionary<TKey, IDataTemplate> Templates { get; } = new();
+
+    public bool Match(object? data) => data is ITemplateKey<TKey>;
+
+    /// <inheritdoc />
+    public Control Build(object? data)
+    {
+        if (data is not ITemplateKey<TKey> key)
+            throw new ArgumentException(null, nameof(data));
+
+        if (Templates.TryGetValue(key.TemplateKey, out var template))
+        {
+            return template.Build(data)!;
+        }
+
+        if (DefaultKey is not null && Templates.TryGetValue(DefaultKey, out var defaultTemplate))
+        {
+            return defaultTemplate.Build(data)!;
+        }
+
+        throw new ArgumentException(null, nameof(data));
+    }
+}

StabilityMatrix.Avalonia/Controls/Inference/ModelCard.axaml

@@ -7,11 +7,14 @@
     xmlns:mocks="clr-namespace:StabilityMatrix.Avalonia.DesignData"
     xmlns:models="clr-namespace:StabilityMatrix.Core.Models;assembly=StabilityMatrix.Core"
     xmlns:ui="clr-namespace:FluentAvalonia.UI.Controls;assembly=FluentAvalonia"
+    xmlns:converters="clr-namespace:StabilityMatrix.Avalonia.Converters"
+    xmlns:sg="clr-namespace:SpacedGridControl.Avalonia;assembly=SpacedGridControl.Avalonia"
     x:DataType="inference:ModelCardViewModel">
     <Design.PreviewWith>
         <Panel Width="400" Height="200">
             <StackPanel Width="300" VerticalAlignment="Center">
                 <controls:ModelCard DataContext="{x:Static mocks:DesignData.ModelCardViewModel}" />
+                <controls:ModelCard DataContext="{x:Static mocks:DesignData.ImgToVidModelCardViewModel}" />
             </StackPanel>
         </Panel>
     </Design.PreviewWith>
@@ -21,126 +24,39 @@
         <Setter Property="Template">
             <ControlTemplate>
                 <controls:Card Padding="12">
-                    <Grid ColumnDefinitions="Auto,*,Auto" RowDefinitions="*,*,*">
+                    <sg:SpacedGrid
+                        ColumnSpacing="8"
+                        RowSpacing="0"
+                        ColumnDefinitions="Auto,*,Auto" 
+                        RowDefinitions="*,*,*,*">
                         <!--  Model  -->
                         <TextBlock
                             Grid.Column="0"
-                            MinWidth="60"
                             VerticalAlignment="Center"
                             Text="{x:Static lang:Resources.Label_Model}"
                             TextAlignment="Left" />
-                        <ui:FAComboBox
+                        
+                        <controls:BetterComboBox
                             Grid.Row="0"
                             Grid.Column="1"
-                            Theme="{StaticResource FAComboBoxHybridModelTheme}"
+                            Padding="8,6,4,6"
+                            Theme="{StaticResource  BetterComboBoxHybridModelTheme}"
                             HorizontalAlignment="Stretch"
                             ItemsSource="{Binding ClientManager.Models}"
-                            SelectedItem="{Binding SelectedModel}">
-                            <!--<ui:FAComboBox.Styles>
-                                <Style Selector="ui|FAComboBoxItem">
-                                    <Setter Property="ToolTip.Placement" Value="RightEdgeAlignedTop" />
-                                    <Setter Property="ToolTip.Tip">
-                                        <Template>
-                                            <StackPanel
-                                                x:DataType="models:HybridModelFile"
-                                                Orientation="Horizontal"
-                                                Spacing="6">
-                                                ~1~  Image  @1@
-                                                <controls:BetterAdvancedImage
-                                                    Width="64"
-                                                    Height="96"
-                                                    CornerRadius="6"
-                                                    IsVisible="{Binding Local.PreviewImageFullPathGlobal, Converter={x:Static StringConverters.IsNotNullOrEmpty}, FallbackValue=''}"
-                                                    RenderOptions.BitmapInterpolationMode="HighQuality"
-                                                    Source="{Binding Local.PreviewImageFullPathGlobal, FallbackValue=''}"
-                                                    Stretch="UniformToFill"
-                                                    StretchDirection="Both" />
-                                                <Grid RowDefinitions="Auto,Auto,*" VerticalAlignment="Stretch" MaxWidth="300">
-                                                    ~1~  Title  @1@
-                                                    <TextBlock
-                                                        Margin="0,0,0,4"
-                                                        HorizontalAlignment="Left"
-                                                        FontSize="14"
-                                                        FontWeight="Medium"
-                                                        Foreground="{DynamicResource TextFillColorPrimaryBrush}"
-                                                        IsVisible="{Binding Local.ConnectedModelInfo, Converter={x:Static ObjectConverters.IsNotNull}, FallbackValue=False}"
-                                                        Text="{Binding Local.ConnectedModelInfo.ModelName, FallbackValue=''}"
-                                                        TextWrapping="WrapWithOverflow" />
-                                                    ~1~  Version  @1@
-                                                    <TextBlock
-                                                        Grid.Row="1"
-                                                        Margin="0,0,0,8"
-                                                        HorizontalAlignment="Left"
-                                                        FontSize="13"
-                                                        Foreground="{DynamicResource TextFillColorTertiaryBrush}"
-                                                        IsVisible="{Binding Local.ConnectedModelInfo, Converter={x:Static ObjectConverters.IsNotNull}, FallbackValue=False}"
-                                                        Text="{Binding Local.ConnectedModelInfo.VersionName, FallbackValue=''}"
-                                                        TextWrapping="WrapWithOverflow" />
-                                                    ~1~  Path  @1@
-                                                    <TextBlock
-                                                        Grid.Row="2"
-                                                        HorizontalAlignment="Left"
-                                                        FontSize="13"
-                                                        Foreground="{DynamicResource TextFillColorTertiaryBrush}"
-                                                        Text="{Binding RelativePath}"
-                                                        TextWrapping="Wrap" />
-                                                </Grid>
-                                            </StackPanel>
-                                        </Template>
-                                    </Setter>
-                                </Style>
-                                <Style Selector="ui|FAComboBox /template/ ContentControl#ContentPresenter &gt; StackPanel &gt; TextBlock:nth-child(2)">
-                                    <Setter Property="IsVisible" Value="False" />
-                                </Style>
-                            </ui:FAComboBox.Styles>
-                            <ui:FAComboBox.ItemTemplate>
-                                <DataTemplate DataType="models:HybridModelFile">
-                                    <StackPanel ToolTip.Placement="RightEdgeAlignedTop">
-                                        <TextBlock Text="{Binding ShortDisplayName}" TextTrimming="CharacterEllipsis" />
-                                    </StackPanel>
-                                </DataTemplate>
-                            </ui:FAComboBox.ItemTemplate>-->
-                            <!--<ui:FAComboBox.ItemTemplate>
-                                <DataTemplate DataType="models:HybridModelFile">
-                                    <Grid RowDefinitions="Auto,Auto" ColumnDefinitions="Auto,*">
-                                        <controls:BetterAdvancedImage
-                                            Grid.Row="0"
-                                            Grid.Column="0"
-                                            Grid.RowSpan="2"
-                                            Margin="0,0,8,0"
-                                            Height="32"
-                                            Width="32"
-                                            Stretch="UniformToFill"
-                                            StretchDirection="Both"
-                                            RenderOptions.BitmapInterpolationMode="HighQuality"
-                                            Source="{Binding Local.PreviewImageFullPathGlobal}">
-                                            <controls:BetterAdvancedImage.Clip>
-                                                <EllipseGeometry Rect="0,0,32,32" />
-                                            </controls:BetterAdvancedImage.Clip>
-                                        </controls:BetterAdvancedImage>
-                                        <TextBlock
-                                            Grid.Row="0"
-                                            Grid.Column="1"
-                                            Text="{Binding Local.ConnectedModelInfo.VersionName}"/>
-                                        <TextBlock
-                                            FontSize="11"
-                                            Grid.Row="1"
-                                            Grid.Column="1"
-                                            Text="{Binding Local.ConnectedModelInfo.ModelName}"/>
-                                    </Grid>
-                                </DataTemplate>
-                            </ui:FAComboBox.ItemTemplate>-->
-                        </ui:FAComboBox>
+                            SelectedItem="{Binding SelectedModel}"/>
 
                         <Button
                             Grid.Row="0"
                             Grid.Column="2"
-                            Margin="8,0,0,0">
+                            VerticalAlignment="Stretch"
+                            HorizontalAlignment="Stretch"
+                            Margin="0,0,0,0">
                             <ui:SymbolIcon FontSize="16" Symbol="Setting" />
                             <Button.Flyout>
                                 <ui:FAMenuFlyout Placement="BottomEdgeAlignedLeft">
                                     <ui:ToggleMenuFlyoutItem IsChecked="{Binding IsRefinerSelectionEnabled}" Text="{x:Static lang:Resources.Label_Refiner}" />
                                     <ui:ToggleMenuFlyoutItem IsChecked="{Binding IsVaeSelectionEnabled}" Text="{x:Static lang:Resources.Label_VAE}" />
+                                    <ui:ToggleMenuFlyoutItem IsChecked="{Binding IsClipSkipEnabled}" Text="{x:Static lang:Resources.Label_CLIPSkip}" />
                                 </ui:FAMenuFlyout>
                             </Button.Flyout>
                         </Button>
@@ -149,30 +65,28 @@
                         <TextBlock
                             Grid.Row="1"
                             Grid.Column="0"
-                            MinWidth="60"
                             Margin="0,8,0,0"
                             VerticalAlignment="Center"
                             IsVisible="{Binding IsRefinerSelectionEnabled}"
                             Text="{x:Static lang:Resources.Label_Refiner}"
                             TextAlignment="Left" />
 
-                        <ui:FAComboBox
+                        <controls:BetterComboBox
                             Grid.Row="1"
                             Grid.Column="1"
                             Grid.ColumnSpan="2"
                             Margin="0,8,0,0"
-                            HorizontalAlignment="Stretch"
-                            DisplayMemberBinding="{Binding ShortDisplayName}"
-                            IsTextSearchEnabled="True"
+                            Padding="8,6,4,6"
                             IsVisible="{Binding IsRefinerSelectionEnabled}"
+                            Theme="{StaticResource  BetterComboBoxHybridModelTheme}"
+                            HorizontalAlignment="Stretch"
                             ItemsSource="{Binding ClientManager.Models}"
-                            SelectedItem="{Binding SelectedRefiner}" />
+                            SelectedItem="{Binding SelectedRefiner}"/>
                         
                         <!--  VAE  -->
                         <TextBlock
                             Grid.Row="2"
                             Grid.Column="0"
-                            MinWidth="60"
                             Margin="0,8,0,0"
                             VerticalAlignment="Center"
                             IsVisible="{Binding IsVaeSelectionEnabled}"
@@ -191,7 +105,32 @@
                             ItemsSource="{Binding ClientManager.VaeModels}"
                             SelectedItem="{Binding SelectedVae}" />
                         
-                    </Grid>
+                        <!--  CLIP Skip  -->
+                        <TextBlock
+                            Grid.Row="3"
+                            Grid.Column="0"
+                            Margin="0,8,0,0"
+                            VerticalAlignment="Center"
+                            IsVisible="{Binding IsClipSkipEnabled}"
+                            Text="{x:Static lang:Resources.Label_CLIPSkip}"
+                            TextAlignment="Left" />
+
+                        <NumericUpDown
+                            Grid.Row="3"
+                            Grid.Column="1"
+                            Grid.ColumnSpan="2"
+                            IsVisible="{Binding IsClipSkipEnabled}"
+                            Watermark="1"
+                            HorizontalAlignment="Stretch"
+                            Margin="0,8,0,0"
+                            Minimum="1"
+                            Maximum="24"
+                            Increment="1"
+                            ParsingNumberStyle="Integer"
+                            Value="{Binding ClipSkip, Converter={x:Static converters:NullableDefaultNumericConverters.IntToDecimal}}"
+                            ClipValueToMinMax="True"/>
+
+                    </sg:SpacedGrid>
                 </controls:Card>
             </ControlTemplate>
         </Setter>

StabilityMatrix.Avalonia/Controls/VideoGenerationSettingsCard.axaml

@@ -0,0 +1,122 @@
+<Styles xmlns="https://github.com/avaloniaui"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        xmlns:controls="using:StabilityMatrix.Avalonia.Controls"
+        x:DataType="video:SvdImgToVidConditioningViewModel"
+        xmlns:mocks="clr-namespace:StabilityMatrix.Avalonia.DesignData"
+        xmlns:video="clr-namespace:StabilityMatrix.Avalonia.ViewModels.Inference.Video"
+        xmlns:controls1="clr-namespace:FluentAvalonia.UI.Controls;assembly=FluentAvalonia"
+        xmlns:lang="clr-namespace:StabilityMatrix.Avalonia.Languages">
+    <Design.PreviewWith>
+        <Grid MinWidth="400">
+            <controls:VideoGenerationSettingsCard DataContext="{x:Static mocks:DesignData.SvdImgToVidConditioningViewModel}" />
+        </Grid>
+    </Design.PreviewWith>
+
+    <Style Selector="controls|VideoGenerationSettingsCard">
+        <!-- Set Defaults -->
+        <Setter Property="HorizontalAlignment" Value="Stretch" />
+        <Setter Property="Template">
+            <ControlTemplate>
+                <controls:Card Padding="8" HorizontalAlignment="{TemplateBinding HorizontalAlignment}">
+                    <Grid Margin="4" RowDefinitions="Auto,Auto,Auto,Auto,Auto" ColumnDefinitions="Auto, *">
+                        <TextBlock
+                            Grid.Row="0"
+                            Grid.Column="0"
+                            Margin="0,0,8,0"
+                            VerticalAlignment="Center"
+                            Text="{x:Static lang:Resources.Label_Frames}" />
+                        <controls1:NumberBox
+                            Grid.Row="0"
+                            Grid.Column="1"
+                            SelectionHighlightColor="Transparent"
+                            Value="{Binding NumFrames}"
+                            Margin="8,0,0,0"
+                            SimpleNumberFormat="F0"
+                            SmallChange="1"
+                            HorizontalAlignment="Stretch"
+                            SpinButtonPlacementMode="Inline"/>
+                        
+                            <TextBlock
+                                Grid.Row="1"
+                                Grid.Column="0"
+                                Margin="0,8,8,0"
+                                VerticalAlignment="Center"
+                                Text="{x:Static lang:Resources.Label_Fps}" />
+                            <controls1:NumberBox
+                                Grid.Row="1"
+                                Grid.Column="1"
+                                SelectionHighlightColor="Transparent"
+                                Value="{Binding Fps}"
+                                Margin="8,8,0,0"
+                                SimpleNumberFormat="F0"
+                                SmallChange="1"
+                                HorizontalAlignment="Stretch"
+                                SpinButtonPlacementMode="Inline"/>
+                        
+                            <TextBlock
+                                Grid.Row="2"
+                                Grid.Column="0"
+                                Margin="0,8,8,0"
+                                VerticalAlignment="Center"
+                                Text="{x:Static lang:Resources.Label_MinCfg}" />
+                            <controls1:NumberBox
+                                Margin="8,8,0,0"
+                                Grid.Row="2"
+                                Grid.Column="1"
+                                SelectionHighlightColor="Transparent"
+                                Value="{Binding MinCfg}"
+                                SimpleNumberFormat="F0"
+                                SmallChange="1"
+                                HorizontalAlignment="Stretch"
+                                SpinButtonPlacementMode="Inline"/>
+                        
+                            <TextBlock
+                                Margin="0,8,8,0"
+                                Grid.Row="3"
+                                Grid.Column="0"
+                                VerticalAlignment="Center"
+                                Text="{x:Static lang:Resources.Label_MotionBucketId}" />
+                            <controls1:NumberBox
+                                Margin="8,8,0,0"
+                                Grid.Row="3"
+                                Grid.Column="1"
+                                SelectionHighlightColor="Transparent"
+                                Value="{Binding MotionBucketId}"
+                                SimpleNumberFormat="F0"
+                                SmallChange="1"
+                                HorizontalAlignment="Stretch"
+                                SpinButtonPlacementMode="Inline"/>
+                        
+                        <StackPanel Grid.Column="0"
+                                    Grid.ColumnSpan="2"
+                                    Grid.Row="4" 
+                                    Margin="0,16,0,0">
+                            <Grid ColumnDefinitions="*,Auto">
+                                <TextBlock 
+                                    VerticalAlignment="Center"
+                                    Text="{x:Static lang:Resources.Label_AugmentationLevel}" />
+                                <controls1:NumberBox
+                                    Grid.Column="1"
+                                    Margin="4,0,0,0"
+                                    ValidationMode="InvalidInputOverwritten"
+                                    SmallChange="0.01"
+                                    SimpleNumberFormat="F2"
+                                    Value="{Binding AugmentationLevel}"
+                                    HorizontalAlignment="Stretch"
+                                    MinWidth="100"
+                                    SpinButtonPlacementMode="Compact"/>
+                            </Grid>
+                            <Slider 
+                                Minimum="0"
+                                Maximum="10"
+                                Value="{Binding AugmentationLevel}"
+                                TickFrequency="1"
+                                Margin="0,0,0,-4"
+                                TickPlacement="BottomRight"/>
+                        </StackPanel>
+                    </Grid>
+                </controls:Card>
+            </ControlTemplate>
+        </Setter>
+    </Style>
+</Styles>

StabilityMatrix.Avalonia/Controls/VideoGenerationSettingsCard.axaml.cs

@@ -0,0 +1,7 @@
+using Avalonia.Controls.Primitives;
+using StabilityMatrix.Core.Attributes;
+
+namespace StabilityMatrix.Avalonia.Controls;
+
+[Transient]
+public class VideoGenerationSettingsCard : TemplatedControl { }

StabilityMatrix.Avalonia/Controls/VideoOutputSettingsCard.axaml

@@ -0,0 +1,98 @@
+<Styles xmlns="https://github.com/avaloniaui"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        xmlns:controls="using:StabilityMatrix.Avalonia.Controls"
+        x:DataType="video:VideoOutputSettingsCardViewModel"
+        xmlns:mocks="clr-namespace:StabilityMatrix.Avalonia.DesignData"
+        xmlns:video="clr-namespace:StabilityMatrix.Avalonia.ViewModels.Inference.Video"
+        xmlns:controls1="clr-namespace:FluentAvalonia.UI.Controls;assembly=FluentAvalonia"
+        xmlns:lang="clr-namespace:StabilityMatrix.Avalonia.Languages">
+    <Design.PreviewWith>
+        <Grid MinWidth="400">
+            <controls:VideoOutputSettingsCard
+                DataContext="{x:Static mocks:DesignData.SvdImgToVidConditioningViewModel}" />
+        </Grid>
+    </Design.PreviewWith>
+
+    <Style Selector="controls|VideoOutputSettingsCard">
+        <!-- Set Defaults -->
+        <Setter Property="HorizontalAlignment" Value="Stretch" />
+        <Setter Property="Template">
+            <ControlTemplate>
+                <controls:Card Padding="8" HorizontalAlignment="{TemplateBinding HorizontalAlignment}">
+                    <Grid Margin="4" RowDefinitions="Auto,Auto,Auto,Auto,Auto" ColumnDefinitions="Auto, *">
+                        <TextBlock 
+                            Grid.Row="0"
+                            Grid.Column="0"
+                            Grid.ColumnSpan="2"
+                            Text="Video Output Settings"
+                            FontSize="16"
+                            FontWeight="DemiBold"
+                            Margin="0,0,0,16"
+                            />
+                        <TextBlock
+                            Grid.Row="1"
+                            Grid.Column="0"
+                            Margin="0,0,8,0"
+                            VerticalAlignment="Center"
+                            Text="{x:Static lang:Resources.Label_Fps}" />
+                        <controls1:NumberBox
+                            Grid.Row="1"
+                            Grid.Column="1"
+                            SelectionHighlightColor="Transparent"
+                            Value="{Binding Fps}"
+                            Margin="8,0,0,0"
+                            SimpleNumberFormat="F0"
+                            SmallChange="1"
+                            HorizontalAlignment="Stretch"
+                            SpinButtonPlacementMode="Inline" />
+
+                        <TextBlock
+                            Grid.Row="2"
+                            Grid.Column="0"
+                            Margin="0,8,8,0"
+                            VerticalAlignment="Center"
+                            Text="{x:Static lang:Resources.Label_Lossless}" />
+                        <CheckBox
+                            Grid.Row="2"
+                            Grid.Column="1"
+                            IsChecked="{Binding Lossless}"
+                            Margin="8,8,0,0"
+                            HorizontalAlignment="Stretch" />
+
+                        <TextBlock
+                            Grid.Row="3"
+                            Grid.Column="0"
+                            Margin="0,8,8,0"
+                            VerticalAlignment="Center"
+                            Text="{x:Static lang:Resources.Label_VideoQuality}" />
+                        <controls1:NumberBox
+                            Margin="8,8,0,0"
+                            Grid.Row="3"
+                            Grid.Column="1"
+                            SelectionHighlightColor="Transparent"
+                            Value="{Binding Quality}"
+                            SimpleNumberFormat="F0"
+                            SmallChange="1"
+                            Maximum="100"
+                            HorizontalAlignment="Stretch"
+                            SpinButtonPlacementMode="Inline" />
+
+                        <TextBlock
+                            Margin="0,8,8,0"
+                            Grid.Row="4"
+                            Grid.Column="0"
+                            VerticalAlignment="Center"
+                            Text="{x:Static lang:Resources.Label_VideoOutputMethod}" />
+                        <ComboBox
+                            Grid.Row="4"
+                            Grid.Column="1"
+                            Margin="8,8,0,0"
+                            MinWidth="100"
+                            ItemsSource="{Binding AvailableMethods}"
+                            SelectedIndex="{Binding SelectedMethod}" />
+                    </Grid>
+                </controls:Card>
+            </ControlTemplate>
+        </Setter>
+    </Style>
+</Styles>

StabilityMatrix.Avalonia/Controls/VideoOutputSettingsCard.axaml.cs

@@ -0,0 +1,7 @@
+using Avalonia.Controls.Primitives;
+using StabilityMatrix.Core.Attributes;
+
+namespace StabilityMatrix.Avalonia.Controls;
+
+[Transient]
+public class VideoOutputSettingsCard : TemplatedControl { }

StabilityMatrix.Avalonia/DesignData/DesignData.cs

@@ -4,6 +4,7 @@ using System.Collections.ObjectModel;
 using System.ComponentModel;
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
+using System.Linq;
 using System.Net.Http;
 using System.Text;
 using AvaloniaEdit.Utils;
@@ -25,6 +26,7 @@ using StabilityMatrix.Avalonia.ViewModels.CheckpointManager;
 using StabilityMatrix.Avalonia.ViewModels.Dialogs;
 using StabilityMatrix.Avalonia.ViewModels.Inference;
 using StabilityMatrix.Avalonia.ViewModels.Inference.Modules;
+using StabilityMatrix.Avalonia.ViewModels.Inference.Video;
 using StabilityMatrix.Avalonia.ViewModels.OutputsPage;
 using StabilityMatrix.Avalonia.ViewModels.Progress;
 using StabilityMatrix.Avalonia.ViewModels.Settings;
@@ -630,6 +632,14 @@ The gallery images are often inpainted, but you will get something very similar
             vm.OutputProgress.Text = "Sampler 10/30";
         });
 
+    public static InferenceImageToVideoViewModel InferenceImageToVideoViewModel =>
+        DialogFactory.Get<InferenceImageToVideoViewModel>(vm =>
+        {
+            vm.OutputProgress.Value = 10;
+            vm.OutputProgress.Maximum = 30;
+            vm.OutputProgress.Text = "Sampler 10/30";
+        });
+
     public static InferenceImageToImageViewModel InferenceImageToImageViewModel =>
         DialogFactory.Get<InferenceImageToImageViewModel>();
 
@@ -652,6 +662,8 @@ The gallery images are often inpainted, but you will get something very similar
         });
 
     public static SeedCardViewModel SeedCardViewModel => new();
+    public static SvdImgToVidConditioningViewModel SvdImgToVidConditioningViewModel => new();
+    public static VideoOutputSettingsCardViewModel VideoOutputSettingsCardViewModel => new();
 
     public static SamplerCardViewModel SamplerCardViewModel =>
         DialogFactory.Get<SamplerCardViewModel>(vm =>
@@ -681,6 +693,9 @@ The gallery images are often inpainted, but you will get something very similar
 
     public static ModelCardViewModel ModelCardViewModel => DialogFactory.Get<ModelCardViewModel>();
 
+    public static ImgToVidModelCardViewModel ImgToVidModelCardViewModel =>
+        DialogFactory.Get<ImgToVidModelCardViewModel>();
+
     public static ImageGalleryCardViewModel ImageGalleryCardViewModel =>
         DialogFactory.Get<ImageGalleryCardViewModel>(vm =>
         {
@@ -790,6 +805,43 @@ The gallery images are often inpainted, but you will get something very similar
         }
     }
 
+    public static IEnumerable<HybridModelFile> SampleHybridModels { get; } =
+
+        [
+            HybridModelFile.FromLocal(
+                new LocalModelFile
+                {
+                    SharedFolderType = SharedFolderType.StableDiffusion,
+                    RelativePath = "art_shaper_v8.safetensors",
+                    PreviewImageFullPath =
+                        "https://image.civitai.com/xG1nkqKTMzGDvpLrqFT7WA/dd9b038c-bd15-43ab-86ab-66e145ad7ff2/width=512",
+                    ConnectedModelInfo = new ConnectedModelInfo
+                    {
+                        ModelName = "Art Shaper (very long name example)",
+                        VersionName = "Style v8 (very long name)"
+                    }
+                }
+            ),
+            HybridModelFile.FromLocal(
+                new LocalModelFile
+                {
+                    SharedFolderType = SharedFolderType.StableDiffusion,
+                    RelativePath = "background_arts.safetensors",
+                    PreviewImageFullPath =
+                        "https://image.civitai.com/xG1nkqKTMzGDvpLrqFT7WA/71c81ddf-d8c3-46b4-843d-9f8f20a9254a/width=512",
+                    ConnectedModelInfo = new ConnectedModelInfo
+                    {
+                        ModelName = "Background Arts",
+                        VersionName = "Anime Style v10"
+                    }
+                }
+            ),
+            HybridModelFile.FromRemote("v1-5-pruned-emaonly.safetensors"),
+            HybridModelFile.FromRemote("sample-model.pt"),
+        ];
+
+    public static HybridModelFile SampleHybridModel => SampleHybridModels.First();
+
     public static ImageViewerViewModel ImageViewerViewModel =>
         DialogFactory.Get<ImageViewerViewModel>(vm =>
         {

StabilityMatrix.Avalonia/DialogHelper.cs

@@ -23,15 +23,15 @@ using NLog;
 using Refit;
 using StabilityMatrix.Avalonia.Controls;
 using StabilityMatrix.Avalonia.Helpers;
+using StabilityMatrix.Avalonia.Languages;
+using StabilityMatrix.Avalonia.Models;
 using StabilityMatrix.Core.Exceptions;
 using StabilityMatrix.Core.Extensions;
+using StabilityMatrix.Core.Helper;
 using StabilityMatrix.Core.Models;
 using StabilityMatrix.Core.Services;
 using TextMateSharp.Grammars;
 using Process = FuzzySharp.Process;
-using StabilityMatrix.Avalonia.Languages;
-using StabilityMatrix.Avalonia.Models;
-using StabilityMatrix.Core.Helper;
 
 namespace StabilityMatrix.Avalonia;
 
@@ -48,11 +48,7 @@ public static class DialogHelper
         IReadOnlyList<TextBoxField> textFields
     )
     {
-        return CreateTextEntryDialog(
-            title,
-            new MarkdownScrollViewer { Markdown = description },
-            textFields
-        );
+        return CreateTextEntryDialog(title, new MarkdownScrollViewer { Markdown = description }, textFields);
     }
 
     /// <summary>
@@ -80,11 +76,7 @@ public static class DialogHelper
 
         var grid = new Grid
         {
-            RowDefinitions =
-            {
-                new RowDefinition(GridLength.Star),
-                new RowDefinition(GridLength.Auto)
-            },
+            RowDefinitions = { new RowDefinition(GridLength.Star), new RowDefinition(GridLength.Auto) },
             Children = { markdown, image }
         };
 
@@ -109,18 +101,14 @@ public static class DialogHelper
 
         var grid = new Grid
         {
-            RowDefinitions =
-            {
-                new RowDefinition(GridLength.Auto),
-                new RowDefinition(GridLength.Star)
-            },
+            RowDefinitions = { new RowDefinition(GridLength.Auto), new RowDefinition(GridLength.Star) },
             Children = { content, stackPanel }
         };
         grid.Loaded += (_, _) =>
         {
             // Focus first TextBox
-            var firstTextBox = stackPanel.Children
-                .OfType<StackPanel>()
+            var firstTextBox = stackPanel
+                .Children.OfType<StackPanel>()
                 .FirstOrDefault()
                 .FindDescendantOfType<TextBox>();
             firstTextBox!.Focus();
@@ -254,16 +242,16 @@ public static class DialogHelper
             Content = viewer,
             CloseButtonText = Resources.Action_Close,
             IsPrimaryButtonEnabled = false,
+            MinDialogWidth = 800,
+            MaxDialogHeight = 1000,
+            MaxDialogWidth = 1000
         };
     }
 
     /// <summary>
     /// Create a dialog for displaying an ApiException
     /// </summary>
-    public static BetterContentDialog CreateApiExceptionDialog(
-        ApiException exception,
-        string? title = null
-    )
+    public static BetterContentDialog CreateApiExceptionDialog(ApiException exception, string? title = null)
     {
         Dispatcher.UIThread.VerifyAccess();
 
@@ -275,9 +263,7 @@ public static class DialogHelper
             Options = { ShowColumnRulers = false, AllowScrollBelowDocument = false }
         };
         var registryOptions = new RegistryOptions(ThemeName.DarkPlus);
-        textEditor
-            .InstallTextMate(registryOptions)
-            .SetGrammar(registryOptions.GetScopeByLanguageId("json"));
+        textEditor.InstallTextMate(registryOptions).SetGrammar(registryOptions.GetScopeByLanguageId("json"));
 
         var mainGrid = new StackPanel
         {
@@ -354,9 +340,7 @@ public static class DialogHelper
             Options = { ShowColumnRulers = false, AllowScrollBelowDocument = false }
         };
         var registryOptions = new RegistryOptions(ThemeName.DarkPlus);
-        textEditor
-            .InstallTextMate(registryOptions)
-            .SetGrammar(registryOptions.GetScopeByLanguageId("json"));
+        textEditor.InstallTextMate(registryOptions).SetGrammar(registryOptions.GetScopeByLanguageId("json"));
 
         var mainGrid = new StackPanel
         {
@@ -437,8 +421,7 @@ public static class DialogHelper
     {
         Dispatcher.UIThread.VerifyAccess();
 
-        var title =
-            exception is PromptSyntaxError ? "Prompt Syntax Error" : "Prompt Validation Error";
+        var title = exception is PromptSyntaxError ? "Prompt Syntax Error" : "Prompt Validation Error";
 
         // Get the index of the error
         var errorIndex = exception.TextOffset;

StabilityMatrix.Avalonia/Extensions/ComfyNodeBuilderExtensions.cs

@@ -20,7 +20,9 @@ public static class ComfyNodeBuilderExtensions
         int? batchIndex = null
     )
     {
-        var emptyLatent = builder.Nodes.AddTypedNode(
+        var emptyLatent = builder
+            .Nodes
+            .AddTypedNode(
                 new ComfyNodeBuilder.EmptyLatentImage
                 {
                     Name = "EmptyLatentImage",
@@ -36,7 +38,8 @@ public static class ComfyNodeBuilderExtensions
         // If batch index is selected, add a LatentFromBatch
         if (batchIndex is not null)
         {
-            builder.Connections.Primary = builder.Nodes
+            builder.Connections.Primary = builder
+                .Nodes
                 .AddNamedNode(
                     ComfyNodeBuilder.LatentFromBatch(
                         "LatentFromBatch",
@@ -64,9 +67,9 @@ public static class ComfyNodeBuilderExtensions
         var sourceImageRelativePath = Path.Combine("Inference", image.GetHashGuidFileNameCached());
 
         // Load source
-        var loadImage = builder.Nodes.AddTypedNode(
-            new ComfyNodeBuilder.LoadImage { Name = "LoadImage", Image = sourceImageRelativePath }
-        );
+        var loadImage = builder
+            .Nodes
+            .AddTypedNode(new ComfyNodeBuilder.LoadImage { Name = "LoadImage", Image = sourceImageRelativePath });
 
         builder.Connections.Primary = loadImage.Output1;
         builder.Connections.PrimarySize = imageSize;
@@ -74,7 +77,8 @@ public static class ComfyNodeBuilderExtensions
         // If batch index is selected, add a LatentFromBatch
         if (batchIndex is not null)
         {
-            builder.Connections.Primary = builder.Nodes
+            builder.Connections.Primary = builder
+                .Nodes
                 .AddNamedNode(
                     ComfyNodeBuilder.LatentFromBatch(
                         "LatentFromBatch",
@@ -93,23 +97,24 @@ public static class ComfyNodeBuilderExtensions
         if (builder.Connections.Primary is null)
             throw new ArgumentException("No Primary");
 
-        var image = builder.Connections.Primary.Match(
+        var image = builder
+            .Connections
+            .Primary
+            .Match(
                 _ =>
                     builder.GetPrimaryAsImage(
                         builder.Connections.PrimaryVAE
-                        ?? builder.Connections.RefinerVAE
-                        ?? builder.Connections.BaseVAE
+                            ?? builder.Connections.Refiner.VAE
+                            ?? builder.Connections.Base.VAE
                             ?? throw new ArgumentException("No Primary, Refiner, or Base VAE")
                     ),
                 image => image
             );
 
-        var previewImage = builder.Nodes.AddTypedNode(
-            new ComfyNodeBuilder.PreviewImage
-            {
-                Name = builder.Nodes.GetUniqueName("SaveImage"),
-                Images = image
-            }
+        var previewImage = builder
+            .Nodes
+            .AddTypedNode(
+                new ComfyNodeBuilder.PreviewImage { Name = builder.Nodes.GetUniqueName("SaveImage"), Images = image }
             );
 
         builder.Connections.OutputNodes.Add(previewImage);

StabilityMatrix.Avalonia/Languages/Resources.Designer.cs

@@ -707,6 +707,15 @@ namespace StabilityMatrix.Avalonia.Languages {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Augmentation Level.
+        /// </summary>
+        public static string Label_AugmentationLevel {
+            get {
+                return ResourceManager.GetString("Label_AugmentationLevel", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Auto Completion.
         /// </summary>
@@ -833,6 +842,15 @@ namespace StabilityMatrix.Avalonia.Languages {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to CLIP Skip.
+        /// </summary>
+        public static string Label_CLIPSkip {
+            get {
+                return ResourceManager.GetString("Label_CLIPSkip", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Close dialog when finished.
         /// </summary>
@@ -1184,6 +1202,24 @@ namespace StabilityMatrix.Avalonia.Languages {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Frames Per Second.
+        /// </summary>
+        public static string Label_Fps {
+            get {
+                return ResourceManager.GetString("Label_Fps", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Frames.
+        /// </summary>
+        public static string Label_Frames {
+            get {
+                return ResourceManager.GetString("Label_Frames", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to General.
         /// </summary>
@@ -1229,6 +1265,15 @@ namespace StabilityMatrix.Avalonia.Languages {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Image to Video.
+        /// </summary>
+        public static string Label_ImageToVideo {
+            get {
+                return ResourceManager.GetString("Label_ImageToVideo", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Image Viewer.
         /// </summary>
@@ -1427,6 +1472,24 @@ namespace StabilityMatrix.Avalonia.Languages {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Lossless.
+        /// </summary>
+        public static string Label_Lossless {
+            get {
+                return ResourceManager.GetString("Label_Lossless", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Min CFG.
+        /// </summary>
+        public static string Label_MinCfg {
+            get {
+                return ResourceManager.GetString("Label_MinCfg", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Missing Image File.
         /// </summary>
@@ -1481,6 +1544,15 @@ namespace StabilityMatrix.Avalonia.Languages {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Motion Bucket ID.
+        /// </summary>
+        public static string Label_MotionBucketId {
+            get {
+                return ResourceManager.GetString("Label_MotionBucketId", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Networks (Lora / LyCORIS).
         /// </summary>
@@ -2156,6 +2228,24 @@ namespace StabilityMatrix.Avalonia.Languages {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Method.
+        /// </summary>
+        public static string Label_VideoOutputMethod {
+            get {
+                return ResourceManager.GetString("Label_VideoOutputMethod", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Quality.
+        /// </summary>
+        public static string Label_VideoQuality {
+            get {
+                return ResourceManager.GetString("Label_VideoQuality", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Waiting to connect....
         /// </summary>

StabilityMatrix.Avalonia/Languages/Resources.resx

@@ -897,4 +897,34 @@
   <data name="Label_HolidayMode" xml:space="preserve">
     <value>Holiday Mode</value>
   </data>
+  <data name="Label_CLIPSkip" xml:space="preserve">
+    <value>CLIP Skip</value>
+  </data>
+  <data name="Label_ImageToVideo" xml:space="preserve">
+    <value>Image to Video</value>
+  </data>
+  <data name="Label_Fps" xml:space="preserve">
+    <value>Frames Per Second</value>
+  </data>
+  <data name="Label_MinCfg" xml:space="preserve">
+    <value>Min CFG</value>
+  </data>
+  <data name="Label_Lossless" xml:space="preserve">
+    <value>Lossless</value>
+  </data>
+  <data name="Label_Frames" xml:space="preserve">
+    <value>Frames</value>
+  </data>
+  <data name="Label_MotionBucketId" xml:space="preserve">
+    <value>Motion Bucket ID</value>
+  </data>
+  <data name="Label_AugmentationLevel" xml:space="preserve">
+    <value>Augmentation Level</value>
+  </data>
+  <data name="Label_VideoOutputMethod" xml:space="preserve">
+    <value>Method</value>
+  </data>
+  <data name="Label_VideoQuality" xml:space="preserve">
+    <value>Quality</value>
+  </data>
 </root>

StabilityMatrix.Avalonia/Models/ITemplateKey.cs

@@ -0,0 +1,11 @@
+using StabilityMatrix.Avalonia.Controls;
+
+namespace StabilityMatrix.Avalonia.Models;
+
+/// <summary>
+/// Implements a template key for <see cref="DataTemplateSelector"/>
+/// </summary>
+public interface ITemplateKey<out T>
+{
+    T TemplateKey { get; }
+}

StabilityMatrix.Avalonia/Models/ImageSource.cs

@@ -12,7 +12,7 @@ using StabilityMatrix.Core.Models.FileInterfaces;
 
 namespace StabilityMatrix.Avalonia.Models;
 
-public record ImageSource : IDisposable
+public record ImageSource : IDisposable, ITemplateKey<ImageSourceTemplateType>
 {
     private Hash? contentHashBlake3;
 
@@ -55,6 +55,23 @@ public record ImageSource : IDisposable
         Bitmap = bitmap;
     }
 
+    /// <inheritdoc />
+    public ImageSourceTemplateType TemplateKey
+    {
+        get
+        {
+            var ext = LocalFile?.Extension ?? Path.GetExtension(RemoteUrl?.ToString());
+
+            if (ext is not null && ext.Equals(".webp", StringComparison.OrdinalIgnoreCase))
+            {
+                // TODO: Check if webp is animated
+                return ImageSourceTemplateType.WebpAnimation;
+            }
+
+            return ImageSourceTemplateType.Image;
+        }
+    }
+
     [JsonIgnore]
     public Task<Bitmap?> BitmapAsync => GetBitmapAsync();
 

StabilityMatrix.Avalonia/Models/ImageSourceTemplateType.cs

@@ -0,0 +1,8 @@
+namespace StabilityMatrix.Avalonia.Models;
+
+public enum ImageSourceTemplateType
+{
+    Default,
+    Image,
+    WebpAnimation
+}

StabilityMatrix.Avalonia/Models/Inference/ModuleApplyStepEventArgs.cs

@@ -1,7 +1,7 @@
 using System;
 using System.Collections.Generic;
-using StabilityMatrix.Core.Models.Api.Comfy.Nodes;
 using StabilityMatrix.Core.Models.Api.Comfy.NodeTypes;
+using StabilityMatrix.Core.Models.Api.Comfy.Nodes;
 
 namespace StabilityMatrix.Avalonia.Models.Inference;
 
@@ -29,26 +29,19 @@ public class ModuleApplyStepEventArgs : EventArgs
     /// <summary>
     /// Generation overrides (like hires fix generate, current seed generate, etc.)
     /// </summary>
-    public IReadOnlyDictionary<Type, bool> IsEnabledOverrides { get; init; } =
-        new Dictionary<Type, bool>();
+    public IReadOnlyDictionary<Type, bool> IsEnabledOverrides { get; init; } = new Dictionary<Type, bool>();
 
     public class ModuleApplyStepTemporaryArgs
     {
         /// <summary>
         /// Temporary conditioning apply step, used by samplers to apply control net.
         /// </summary>
-        public (
-            ConditioningNodeConnection Positive,
-            ConditioningNodeConnection Negative
-        )? Conditioning { get; set; }
+        public ConditioningConnections? Conditioning { get; set; }
 
         /// <summary>
         /// Temporary refiner conditioning apply step, used by samplers to apply control net.
         /// </summary>
-        public (
-            ConditioningNodeConnection Positive,
-            ConditioningNodeConnection Negative
-        )? RefinerConditioning { get; set; }
+        public ConditioningConnections? RefinerConditioning { get; set; }
 
         /// <summary>
         /// Temporary model apply step, used by samplers to apply control net.

StabilityMatrix.Avalonia/Models/Inference/VideoOutputMethod.cs

@@ -0,0 +1,11 @@
+using System.Text.Json.Serialization;
+
+namespace StabilityMatrix.Avalonia.Models.Inference;
+
+[JsonConverter(typeof(JsonStringEnumConverter))]
+public enum VideoOutputMethod
+{
+    Fastest,
+    Default,
+    Slowest,
+}

StabilityMatrix.Avalonia/Models/InferenceProjectDocument.cs

@@ -33,7 +33,7 @@ public class InferenceProjectDocument : ICloneable
                 InferenceImageToImageViewModel => InferenceProjectType.ImageToImage,
                 InferenceTextToImageViewModel => InferenceProjectType.TextToImage,
                 InferenceImageUpscaleViewModel => InferenceProjectType.Upscale,
-                _ => throw new InvalidOperationException($"Unknown loadable model type: {loadableModel.GetType()}")
+                InferenceImageToVideoViewModel => InferenceProjectType.ImageToVideo,
             },
             State = loadableModel.SaveStateToJsonObject()
         };

StabilityMatrix.Avalonia/Models/InferenceProjectType.cs

@@ -9,7 +9,8 @@ public enum InferenceProjectType
     TextToImage,
     ImageToImage,
     Inpainting,
-    Upscale
+    Upscale,
+    ImageToVideo
 }
 
 public static class InferenceProjectTypeExtensions
@@ -22,6 +23,7 @@ public static class InferenceProjectTypeExtensions
             InferenceProjectType.ImageToImage => typeof(InferenceImageToImageViewModel),
             InferenceProjectType.Inpainting => null,
             InferenceProjectType.Upscale => typeof(InferenceImageUpscaleViewModel),
+            InferenceProjectType.ImageToVideo => typeof(InferenceImageToVideoViewModel),
             InferenceProjectType.Unknown => null,
             _ => throw new ArgumentOutOfRangeException(nameof(type), type, null)
         };

StabilityMatrix.Avalonia/StabilityMatrix.Avalonia.csproj

@@ -1,5 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
     <PropertyGroup>
+        <CFBundleName>Stability Matrix</CFBundleName>
         <OutputType>WinExe</OutputType>
         <TargetFramework>net8.0</TargetFramework>
         <RuntimeIdentifiers>win-x64;linux-x64;osx-x64;osx-arm64</RuntimeIdentifiers>
@@ -8,12 +9,19 @@
         <ApplicationManifest>app.manifest</ApplicationManifest>
         <AvaloniaUseCompiledBindingsByDefault>true</AvaloniaUseCompiledBindingsByDefault>
         <ApplicationIcon>./Assets/Icon.ico</ApplicationIcon>
-        <Version>2.7.0-pre.999</Version>
+        <Version>2.8.0-dev.999</Version>
         <InformationalVersion>$(Version)</InformationalVersion>
         <EnableWindowsTargeting>true</EnableWindowsTargeting>
         <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     </PropertyGroup>
 
+    <ItemGroup>
+        <CFBundleURLTypes Include="dummy">
+            <CFBundleURLName>StabilityMatrix.URL</CFBundleURLName>
+            <CFBundleURLSchemes>stabilitymatrix;stabilitymatrix://</CFBundleURLSchemes>
+        </CFBundleURLTypes>
+    </ItemGroup>
+    
     <ItemGroup>
         <InternalsVisibleTo Include="StabilityMatrix.Tests" />
         <InternalsVisibleTo Include="StabilityMatrix.UITests" />
@@ -41,6 +49,7 @@
         <PackageReference Include="Dock.Model.Avalonia" Version="11.0.0.5" />
         <PackageReference Include="Dock.Serializer" Version="11.0.0.5" />
         <PackageReference Include="DynamicData" Version="8.3.27" />
+        <PackageReference Include="DotNet.Bundle" Version="0.9.13" />
         <PackageReference Include="Exceptionless.DateTimeExtensions" Version="3.4.3" />
         <PackageReference Include="FluentAvalonia.BreadcrumbBar" Version="2.0.2" />
         <PackageReference Include="FluentAvaloniaUI" Version="2.0.4" />
@@ -91,6 +100,7 @@
     </ItemGroup>
     
     <ItemGroup>
+        <ProjectReference Include="..\Avalonia.Gif\Avalonia.Gif.csproj" />
         <ProjectReference Include="..\StabilityMatrix.Core\StabilityMatrix.Core.csproj" />
     </ItemGroup>
 
@@ -142,6 +152,18 @@
         <AutoGen>True</AutoGen>
         <DependentUpon>Resources.resx</DependentUpon>
       </Compile>
+      <Compile Update="Views\Inference\InferenceImageToVideoView.axaml.cs">
+        <DependentUpon>InferenceImageToVideoView.axaml</DependentUpon>
+        <SubType>Code</SubType>
+      </Compile>
+      <Compile Update="Controls\VideoGenerationSettingsCard.axaml.cs">
+        <DependentUpon>VideoGenerationSettingsCard.axaml</DependentUpon>
+        <SubType>Code</SubType>
+      </Compile>
+      <Compile Update="Controls\VideoOutputSettingsCard.axaml.cs">
+        <DependentUpon>VideoOutputSettingsCard.axaml</DependentUpon>
+        <SubType>Code</SubType>
+      </Compile>
     </ItemGroup>
 
     <!-- set HUSKY to 0 to disable, or opt-in during CI by setting HUSKY to 1 -->

StabilityMatrix.Avalonia/Styles/ControlThemes/BetterComboBoxStyles.axaml

@@ -0,0 +1,254 @@
+<ResourceDictionary
+    xmlns="https://github.com/avaloniaui"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:controls="clr-namespace:StabilityMatrix.Avalonia.Controls"
+    xmlns:fluentIcons="clr-namespace:FluentIcons.FluentAvalonia;assembly=FluentIcons.FluentAvalonia"
+    xmlns:mocks="using:StabilityMatrix.Avalonia.DesignData"
+    xmlns:models="clr-namespace:StabilityMatrix.Core.Models;assembly=StabilityMatrix.Core"
+    xmlns:sg="clr-namespace:SpacedGridControl.Avalonia;assembly=SpacedGridControl.Avalonia"
+    xmlns:ui="clr-namespace:FluentAvalonia.UI.Controls;assembly=FluentAvalonia">
+
+    <Design.PreviewWith>
+        <Panel Width="450" Height="600">
+            <StackPanel Margin="8" Spacing="4" Width="250">
+                <controls:BetterComboBox
+                    HorizontalAlignment="Stretch"
+                    ItemsSource="{x:Static mocks:DesignData.SampleHybridModels}"
+                    SelectedIndex="0" />
+
+                <controls:BetterComboBox
+                    HorizontalAlignment="Stretch"
+                    ItemsSource="{x:Static mocks:DesignData.SampleHybridModels}"
+                    SelectedIndex="0"
+                    Theme="{DynamicResource BetterComboBoxHybridModelTheme}" />
+            </StackPanel>
+        </Panel>
+    </Design.PreviewWith>
+
+    <!--  ReSharper disable once Xaml.StaticResourceNotResolved  -->
+    <ControlTheme
+        x:Key="BetterComboBoxItemHybridModelTheme"
+        BasedOn="{StaticResource {x:Type ComboBoxItem}}"
+        TargetType="ComboBoxItem">
+        <Setter Property="ToolTip.Placement" Value="RightEdgeAlignedTop" />
+        <Setter Property="ToolTip.Tip">
+            <Template>
+                <sg:SpacedGrid
+                    x:DataType="models:HybridModelFile"
+                    ColumnDefinitions="Auto,*"
+                    ColumnSpacing="6"
+                    RowSpacing="0">
+                    <!--  Image  -->
+                    <controls:BetterAdvancedImage
+                        Width="64"
+                        Height="96"
+                        CornerRadius="6"
+                        IsVisible="{Binding Local.PreviewImageFullPathGlobal, Converter={x:Static StringConverters.IsNotNullOrEmpty}, FallbackValue=''}"
+                        RenderOptions.BitmapInterpolationMode="HighQuality"
+                        Source="{Binding Local.PreviewImageFullPathGlobal, FallbackValue=''}"
+                        Stretch="UniformToFill"
+                        StretchDirection="Both" />
+                    <StackPanel
+                        Grid.Column="1"
+                        MaxWidth="300"
+                        VerticalAlignment="Stretch">
+                        <!--  Title  -->
+                        <TextBlock
+                            Margin="0,0,0,4"
+                            HorizontalAlignment="Left"
+                            FontSize="14"
+                            FontWeight="Medium"
+                            Foreground="{DynamicResource TextFillColorPrimaryBrush}"
+                            IsVisible="{Binding Local.ConnectedModelInfo, Converter={x:Static ObjectConverters.IsNotNull}, FallbackValue=False}"
+                            Text="{Binding Local.ConnectedModelInfo.ModelName, FallbackValue=''}"
+                            TextWrapping="WrapWithOverflow" />
+                        <!--  Version  -->
+                        <TextBlock
+                            Margin="0,0,0,8"
+                            HorizontalAlignment="Left"
+                            FontSize="13"
+                            Foreground="{DynamicResource TextFillColorTertiaryBrush}"
+                            IsVisible="{Binding Local.ConnectedModelInfo, Converter={x:Static ObjectConverters.IsNotNull}, FallbackValue=False}"
+                            Text="{Binding Local.ConnectedModelInfo.VersionName, FallbackValue=''}"
+                            TextWrapping="WrapWithOverflow" />
+                        <!--  Path  -->
+                        <TextBlock
+                            HorizontalAlignment="Left"
+                            FontSize="13"
+                            Foreground="{DynamicResource TextFillColorTertiaryBrush}"
+                            Text="{Binding FileName}"
+                            TextWrapping="Wrap" />
+                    </StackPanel>
+                </sg:SpacedGrid>
+            </Template>
+        </Setter>
+    </ControlTheme>
+    
+    <!--  ReSharper disable once Xaml.StaticResourceNotResolved  -->
+    <ControlTheme
+        x:Key="{x:Type controls:BetterComboBox}"
+        BasedOn="{StaticResource {x:Type ComboBox}}"
+        TargetType="controls:BetterComboBox" />
+
+    <ControlTheme
+        x:Key="BetterComboBoxHybridModelTheme"
+        BasedOn="{StaticResource {x:Type controls:BetterComboBox}}"
+        TargetType="controls:BetterComboBox">
+
+        <ControlTheme.Resources>
+            <controls:HybridModelTemplateSelector x:Key="HybridModelTemplateSelector">
+                <DataTemplate x:Key="{x:Static models:HybridModelType.Downloadable}" DataType="models:HybridModelFile">
+                    <Grid ColumnDefinitions="*,Auto">
+                        <TextBlock Foreground="{DynamicResource ThemeGreyColor}" Text="{Binding ShortDisplayName}" />
+                        <Button
+                            Grid.Column="1"
+                            Margin="8,0,0,0"
+                            Padding="0"
+                            Classes="transparent-full">
+                            <fluentIcons:SymbolIcon
+                                VerticalAlignment="Center"
+                                FontSize="18"
+                                Foreground="{DynamicResource ThemeGreyColor}"
+                                IsFilled="True"
+                                Symbol="CloudArrowDown" />
+                        </Button>
+                    </Grid>
+                </DataTemplate>
+
+                <DataTemplate x:Key="{x:Static models:HybridModelType.Local}" DataType="models:HybridModelFile">
+                    <sg:SpacedGrid
+                        HorizontalAlignment="Stretch"
+                        ColumnDefinitions="Auto,*"
+                        ColumnSpacing="8"
+                        TextBlock.TextTrimming="CharacterEllipsis"
+                        TextBlock.TextWrapping="NoWrap">
+                        <controls:BetterAdvancedImage
+                            Grid.RowSpan="2"
+                            Width="42"
+                            Height="42"
+                            RenderOptions.BitmapInterpolationMode="HighQuality"
+                            Source="{Binding Local.PreviewImageFullPathGlobal}"
+                            Stretch="UniformToFill"
+                            StretchDirection="Both">
+                            <controls:BetterAdvancedImage.Clip>
+                                <EllipseGeometry Rect="0,0,42,42" />
+                            </controls:BetterAdvancedImage.Clip>
+                        </controls:BetterAdvancedImage>
+
+                        <!--  Text  -->
+                        <sg:SpacedGrid
+                            Grid.Row="1"
+                            Grid.Column="1"
+                            RowDefinitions="Auto,Auto,Auto"
+                            RowSpacing="1">
+                            <TextBlock Text="{Binding Local.DisplayModelName}" TextTrimming="CharacterEllipsis" />
+                            <TextBlock
+                                Grid.Row="1"
+                                FontSize="12"
+                                FontWeight="Regular"
+                                Foreground="{DynamicResource TextFillColorSecondaryBrush}"
+                                Text="{Binding Local.DisplayModelVersion}"
+                                TextTrimming="CharacterEllipsis" />
+                            <TextBlock
+                                Grid.Row="2"
+                                FontSize="11"
+                                FontWeight="Normal"
+                                Foreground="{DynamicResource TextFillColorTertiaryBrush}"
+                                Text="{Binding Local.DisplayModelFileName}" />
+                        </sg:SpacedGrid>
+                    </sg:SpacedGrid>
+                </DataTemplate>
+
+                <DataTemplate x:Key="{x:Static models:HybridModelType.None}" DataType="models:HybridModelFile">
+                    <StackPanel>
+                        <TextBlock Text="{Binding ShortDisplayName}" TextTrimming="CharacterEllipsis" />
+                    </StackPanel>
+                </DataTemplate>
+            </controls:HybridModelTemplateSelector>
+
+            <controls:HybridModelTemplateSelector x:Key="HybridModelSelectionBoxTemplateSelector">
+                <DataTemplate x:Key="{x:Static models:HybridModelType.Downloadable}" DataType="models:HybridModelFile">
+                    <Grid ColumnDefinitions="*,Auto">
+                        <TextBlock Foreground="{DynamicResource ThemeGreyColor}" Text="{Binding ShortDisplayName}" />
+                        <Button
+                            Grid.Column="1"
+                            Margin="8,0,0,0"
+                            Padding="0"
+                            Classes="transparent-full">
+                            <fluentIcons:SymbolIcon
+                                VerticalAlignment="Center"
+                                FontSize="18"
+                                Foreground="{DynamicResource ThemeGreyColor}"
+                                IsFilled="True"
+                                Symbol="CloudArrowDown" />
+                        </Button>
+                    </Grid>
+                </DataTemplate>
+
+                <DataTemplate x:Key="{x:Static models:HybridModelType.Local}" DataType="models:HybridModelFile">
+                    <sg:SpacedGrid
+                        HorizontalAlignment="Stretch"
+                        ColumnDefinitions="Auto,*"
+                        ColumnSpacing="8"
+                        TextBlock.TextTrimming="CharacterEllipsis"
+                        TextBlock.TextWrapping="NoWrap">
+                        <controls:BetterAdvancedImage
+                            Grid.RowSpan="2"
+                            Width="36"
+                            Height="36"
+                            RenderOptions.BitmapInterpolationMode="HighQuality"
+                            Source="{Binding Local.PreviewImageFullPathGlobal}"
+                            Stretch="UniformToFill"
+                            StretchDirection="Both">
+                            <controls:BetterAdvancedImage.Clip>
+                                <EllipseGeometry Rect="0,0,36,36" />
+                            </controls:BetterAdvancedImage.Clip>
+                        </controls:BetterAdvancedImage>
+
+                        <!--  Text  -->
+                        <sg:SpacedGrid
+                            Grid.Row="1"
+                            Grid.Column="1"
+                            RowDefinitions="Auto,Auto"
+                            RowSpacing="1">
+
+                            <TextBlock Text="{Binding Local.DisplayModelName}" TextTrimming="CharacterEllipsis" />
+                            <TextBlock
+                                Grid.Row="1"
+                                FontSize="12"
+                                FontWeight="Regular"
+                                Foreground="{DynamicResource TextFillColorSecondaryBrush}"
+                                Text="{Binding Local.DisplayModelVersion}"
+                                TextTrimming="CharacterEllipsis" />
+                        </sg:SpacedGrid>
+                    </sg:SpacedGrid>
+                </DataTemplate>
+
+                <DataTemplate x:Key="{x:Static models:HybridModelType.None}" DataType="models:HybridModelFile">
+                    <StackPanel>
+                        <TextBlock Text="{Binding ShortDisplayName}" TextTrimming="CharacterEllipsis" />
+                    </StackPanel>
+                </DataTemplate>
+            </controls:HybridModelTemplateSelector>
+        </ControlTheme.Resources>
+
+        <Setter Property="TextBlock.TextWrapping" Value="NoWrap" />
+        <Setter Property="SelectionBoxItemTemplate" Value="{StaticResource HybridModelSelectionBoxTemplateSelector}" />
+        <Setter Property="ItemTemplate" Value="{StaticResource HybridModelTemplateSelector}" />
+        <Setter Property="ItemContainerTheme" Value="{StaticResource BetterComboBoxItemHybridModelTheme}" />
+        
+        <Style Selector="^ /template/ Popup#PART_Popup">
+            <Setter Property="Width" Value="400" />
+            <Setter Property="Placement" Value="Bottom" />
+            <Setter Property="ScrollViewer.HorizontalScrollBarVisibility" Value="Disabled" />
+            <Setter Property="Effect">
+                <DropShadowEffect
+                    BlurRadius="32"
+                    Opacity="0.6"
+                    Color="#FF000000" />
+            </Setter>
+        </Style>
+
+    </ControlTheme>
+
+</ResourceDictionary>

StabilityMatrix.Avalonia/Styles/FAComboBoxStyles.axaml

@@ -2,11 +2,20 @@
     xmlns="https://github.com/avaloniaui"
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
     xmlns:controls="clr-namespace:StabilityMatrix.Avalonia.Controls"
+    xmlns:fluentIcons="clr-namespace:FluentIcons.FluentAvalonia;assembly=FluentIcons.FluentAvalonia"
+    xmlns:mocks="using:StabilityMatrix.Avalonia.DesignData"
     xmlns:models="clr-namespace:StabilityMatrix.Core.Models;assembly=StabilityMatrix.Core"
+    xmlns:sg="clr-namespace:SpacedGridControl.Avalonia;assembly=SpacedGridControl.Avalonia"
     xmlns:ui="clr-namespace:FluentAvalonia.UI.Controls;assembly=FluentAvalonia">
     <Design.PreviewWith>
-        <Panel Width="400" Height="600">
-            <Panel Width="350" Height="200" />
+        <Panel Width="250" Height="600">
+            <StackPanel Margin="8" Spacing="4">
+                <ui:FAComboBox
+                    HorizontalAlignment="Stretch"
+                    SelectedIndex="0"
+                    Theme="{DynamicResource FAComboBoxHybridModelTheme}"
+                    ItemsSource="{x:Static mocks:DesignData.SampleHybridModels}"/>
+            </StackPanel>
         </Panel>
     </Design.PreviewWith>
 
@@ -15,20 +24,14 @@
         x:Key="FAComboBoxItemHybridModelTheme"
         BasedOn="{StaticResource {x:Type ui:FAComboBoxItem}}"
         TargetType="ui:FAComboBoxItem">
-        <!--<Setter Property="ContentTemplate">
-            <DataTemplate DataType="models:HybridModelFile">
-                <StackPanel>
-                    <TextBlock Text="{Binding ShortDisplayName}" TextTrimming="CharacterEllipsis" />
-                </StackPanel>
-            </DataTemplate>
-        </Setter>-->
         <Setter Property="ToolTip.Placement" Value="RightEdgeAlignedTop" />
         <Setter Property="ToolTip.Tip">
             <Template>
-                <StackPanel
+                <sg:SpacedGrid
                     x:DataType="models:HybridModelFile"
-                    Orientation="Horizontal"
-                    Spacing="6">
+                    ColumnDefinitions="Auto,*"
+                    ColumnSpacing="6"
+                    RowSpacing="0">
                     <!--  Image  -->
                     <controls:BetterAdvancedImage
                         Width="64"
@@ -39,10 +42,7 @@
                         Source="{Binding Local.PreviewImageFullPathGlobal, FallbackValue=''}"
                         Stretch="UniformToFill"
                         StretchDirection="Both" />
-                    <Grid
-                        MaxWidth="300"
-                        VerticalAlignment="Stretch"
-                        RowDefinitions="Auto,Auto,*">
+                    <StackPanel Grid.Column="1" MaxWidth="300">
                         <!--  Title  -->
                         <TextBlock
                             Margin="0,0,0,4"
@@ -51,28 +51,26 @@
                             FontWeight="Medium"
                             Foreground="{DynamicResource TextFillColorPrimaryBrush}"
                             IsVisible="{Binding Local.ConnectedModelInfo, Converter={x:Static ObjectConverters.IsNotNull}, FallbackValue=False}"
-                            Text="{Binding Local.ConnectedModelInfo.ModelName, FallbackValue=''}"
+                            Text="{Binding Local.DisplayModelName}"
                             TextWrapping="WrapWithOverflow" />
                         <!--  Version  -->
                         <TextBlock
-                            Grid.Row="1"
                             Margin="0,0,0,8"
                             HorizontalAlignment="Left"
                             FontSize="13"
                             Foreground="{DynamicResource TextFillColorTertiaryBrush}"
                             IsVisible="{Binding Local.ConnectedModelInfo, Converter={x:Static ObjectConverters.IsNotNull}, FallbackValue=False}"
-                            Text="{Binding Local.ConnectedModelInfo.VersionName, FallbackValue=''}"
+                            Text="{Binding Local.DisplayModelVersion}"
                             TextWrapping="WrapWithOverflow" />
                         <!--  Path  -->
                         <TextBlock
-                            Grid.Row="2"
                             HorizontalAlignment="Left"
                             FontSize="13"
                             Foreground="{DynamicResource TextFillColorTertiaryBrush}"
                             Text="{Binding FileName}"
                             TextWrapping="Wrap" />
-                    </Grid>
                     </StackPanel>
+                </sg:SpacedGrid>
             </Template>
         </Setter>
     </ControlTheme>
@@ -88,7 +86,7 @@
                 </StackPanel>
             </DataTemplate>
         </Setter>
-        <Setter Property="ItemContainerTheme" Value="{StaticResource FAComboBoxItemHybridModelTheme}"/>
+        <Setter Property="ItemContainerTheme" Value="{StaticResource FAComboBoxItemHybridModelTheme}" />
     </ControlTheme>
 
 </ResourceDictionary>

StabilityMatrix.Avalonia/ViewModels/Base/InferenceGenerationViewModelBase.cs

@@ -1,11 +1,12 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
-using System.ComponentModel.DataAnnotations;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Linq;
+using System.Management;
+using System.Text.Json;
 using System.Text.Json.Serialization;
 using System.Threading;
 using System.Threading.Tasks;
@@ -13,6 +14,8 @@ using AsyncAwaitBestPractices;
 using Avalonia.Controls.Notifications;
 using Avalonia.Threading;
 using CommunityToolkit.Mvvm.Input;
+using ExifLibrary;
+using MetadataExtractor.Formats.Exif;
 using NLog;
 using Refit;
 using SkiaSharp;
@@ -24,6 +27,7 @@ using StabilityMatrix.Avalonia.Services;
 using StabilityMatrix.Avalonia.ViewModels.Dialogs;
 using StabilityMatrix.Avalonia.ViewModels.Inference;
 using StabilityMatrix.Avalonia.ViewModels.Inference.Modules;
+using StabilityMatrix.Core.Animation;
 using StabilityMatrix.Core.Exceptions;
 using StabilityMatrix.Core.Extensions;
 using StabilityMatrix.Core.Helper;
@@ -42,7 +46,9 @@ namespace StabilityMatrix.Avalonia.ViewModels.Base;
 /// This includes a progress reporter, image output view model, and generation virtual methods.
 /// </summary>
 [SuppressMessage("ReSharper", "VirtualMemberNeverOverridden.Global")]
-public abstract partial class InferenceGenerationViewModelBase : InferenceTabViewModelBase, IImageGalleryComponent
+public abstract partial class InferenceGenerationViewModelBase
+    : InferenceTabViewModelBase,
+        IImageGalleryComponent
 {
     private static readonly Logger Logger = LogManager.GetCurrentClassLogger();
 
@@ -91,13 +97,22 @@ public abstract partial class InferenceGenerationViewModelBase : InferenceTabVie
         ImageGenerationEventArgs args,
         int batchNum = 0,
         int batchTotal = 0,
-        bool isGrid = false
+        bool isGrid = false,
+        string fileExtension = "png"
     )
     {
         var defaultOutputDir = settingsManager.ImagesInferenceDirectory;
         defaultOutputDir.Create();
 
-        return WriteOutputImageAsync(imageStream, defaultOutputDir, args, batchNum, batchTotal, isGrid);
+        return WriteOutputImageAsync(
+            imageStream,
+            defaultOutputDir,
+            args,
+            batchNum,
+            batchTotal,
+            isGrid,
+            fileExtension
+        );
     }
 
     /// <summary>
@@ -109,7 +124,8 @@ public abstract partial class InferenceGenerationViewModelBase : InferenceTabVie
         ImageGenerationEventArgs args,
         int batchNum = 0,
         int batchTotal = 0,
-        bool isGrid = false
+        bool isGrid = false,
+        string fileExtension = "png"
     )
     {
         var formatTemplateStr = settingsManager.Settings.InferenceOutputImageFileNameFormat;
@@ -128,7 +144,10 @@ public abstract partial class InferenceGenerationViewModelBase : InferenceTabVie
         )
         {
             // Fallback to default
-            Logger.Warn("Failed to parse format template: {FormatTemplate}, using default", formatTemplateStr);
+            Logger.Warn(
+                "Failed to parse format template: {FormatTemplate}, using default",
+                formatTemplateStr
+            );
 
             format = FileNameFormat.Parse(FileNameFormat.DefaultTemplate, formatProvider);
         }
@@ -144,7 +163,7 @@ public abstract partial class InferenceGenerationViewModelBase : InferenceTabVie
         }
 
         var fileName = format.GetFileName();
-        var file = outputDir.JoinFile($"{fileName}.png");
+        var file = outputDir.JoinFile($"{fileName}.{fileExtension}");
 
         // Until the file is free, keep adding _{i} to the end
         for (var i = 0; i < 100; i++)
@@ -152,14 +171,14 @@ public abstract partial class InferenceGenerationViewModelBase : InferenceTabVie
             if (!file.Exists)
                 break;
 
-            file = outputDir.JoinFile($"{fileName}_{i + 1}.png");
+            file = outputDir.JoinFile($"{fileName}_{i + 1}.{fileExtension}");
         }
 
         // If that fails, append an 7-char uuid
         if (file.Exists)
         {
             var uuid = Guid.NewGuid().ToString("N")[..7];
-            file = outputDir.JoinFile($"{fileName}_{uuid}.png");
+            file = outputDir.JoinFile($"{fileName}_{uuid}.{fileExtension}");
         }
 
         await using var fileStream = file.Info.OpenWrite();
@@ -270,8 +289,6 @@ public abstract partial class InferenceGenerationViewModelBase : InferenceTabVie
             // if progress updates are received before the prompt starts
             Task.Run(
                     async () =>
-                    {
-                        try
                     {
                         var delayTime = 250 - (int)timer.ElapsedMilliseconds;
                         if (delayTime > 0)
@@ -280,8 +297,6 @@ public abstract partial class InferenceGenerationViewModelBase : InferenceTabVie
                         }
                         // ReSharper disable once AccessToDisposedClosure
                         AttachRunningNodeChangedHandler(promptTask);
-                        }
-                        catch (TaskCanceledException) { }
                     },
                     cancellationToken
                 )
@@ -305,10 +320,17 @@ public abstract partial class InferenceGenerationViewModelBase : InferenceTabVie
             // Get output images
             var imageOutputs = await client.GetImagesForExecutedPromptAsync(promptTask.Id, cancellationToken);
 
-            if (imageOutputs.Values.All(images => images is null or { Count: 0 }))
+            if (
+                !imageOutputs.TryGetValue(args.OutputNodeNames[0], out var images)
+                || images is not { Count: > 0 }
+            )
             {
                 // No images match
-                notificationService.Show("No output", "Did not receive any output images", NotificationType.Warning);
+                notificationService.Show(
+                    "No output",
+                    "Did not receive any output images",
+                    NotificationType.Warning
+                );
                 return;
             }
 
@@ -320,7 +342,7 @@ public abstract partial class InferenceGenerationViewModelBase : InferenceTabVie
                 ImageGalleryCardViewModel.ImageSources.Clear();
             }
 
-            await ProcessAllOutputImages(imageOutputs, args);
+            await ProcessOutputImages(images, args);
         }
         finally
         {
@@ -338,30 +360,12 @@ public abstract partial class InferenceGenerationViewModelBase : InferenceTabVie
         }
     }
 
-    private async Task ProcessAllOutputImages(
-        IReadOnlyDictionary<string, List<ComfyImage>?> images,
-        ImageGenerationEventArgs args
-    )
-    {
-        foreach (var (nodeName, imageList) in images)
-        {
-            if (imageList is null)
-            {
-                Logger.Warn("No images for node {NodeName}", nodeName);
-                continue;
-            }
-
-            await ProcessOutputImages(imageList, args, nodeName.Replace('_', ' '));
-        }
-    }
-
     /// <summary>
     /// Handles image output metadata for generation runs
     /// </summary>
     private async Task ProcessOutputImages(
         IReadOnlyCollection<ComfyImage> images,
-        ImageGenerationEventArgs args,
-        string? imageLabel = null
+        ImageGenerationEventArgs args
     )
     {
         var client = args.Client;
@@ -405,15 +409,65 @@ public abstract partial class InferenceGenerationViewModelBase : InferenceTabVie
                 );
             }
 
+            if (comfyImage.FileName.EndsWith(".png"))
+            {
                 var bytesWithMetadata = PngDataHelper.AddMetadata(imageArray, parameters, project);
 
                 // Write using generated name
-            var filePath = await WriteOutputImageAsync(new MemoryStream(bytesWithMetadata), args, i + 1, images.Count);
+                var filePath = await WriteOutputImageAsync(
+                    new MemoryStream(bytesWithMetadata),
+                    args,
+                    i + 1,
+                    images.Count
+                );
+
+                outputImages.Add(new ImageSource(filePath));
+                EventManager.Instance.OnImageFileAdded(filePath);
+            }
+            else if (comfyImage.FileName.EndsWith(".webp"))
+            {
+                var opts = new JsonSerializerOptions
+                {
+                    DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
+                    Converters = { new JsonStringEnumConverter() }
+                };
+                var paramsJson = JsonSerializer.Serialize(parameters, opts);
+                var smProject = JsonSerializer.Serialize(project, opts);
+                var metadata = new Dictionary<ExifTag, string>
+                {
+                    { ExifTag.ImageDescription, paramsJson },
+                    { ExifTag.Software, smProject }
+                };
+
+                var bytesWithMetadata = ImageMetadata.AddMetadataToWebp(imageArray, metadata);
+
+                // Write using generated name
+                var filePath = await WriteOutputImageAsync(
+                    new MemoryStream(bytesWithMetadata.ToArray()),
+                    args,
+                    i + 1,
+                    images.Count,
+                    fileExtension: Path.GetExtension(comfyImage.FileName).Replace(".", "")
+                );
 
-            outputImages.Add(new ImageSource(filePath) { Label = imageLabel });
+                outputImages.Add(new ImageSource(filePath));
+                EventManager.Instance.OnImageFileAdded(filePath);
+            }
+            else
+            {
+                // Write using generated name
+                var filePath = await WriteOutputImageAsync(
+                    new MemoryStream(imageArray),
+                    args,
+                    i + 1,
+                    images.Count,
+                    fileExtension: Path.GetExtension(comfyImage.FileName).Replace(".", "")
+                );
 
+                outputImages.Add(new ImageSource(filePath));
                 EventManager.Instance.OnImageFileAdded(filePath);
             }
+        }
 
         // Download all images to make grid, if multiple
         if (outputImages.Count > 1)
@@ -430,11 +484,14 @@ public abstract partial class InferenceGenerationViewModelBase : InferenceTabVie
             var gridBytesWithMetadata = PngDataHelper.AddMetadata(gridBytes, args.Parameters!, args.Project!);
 
             // Save to disk
-            var gridPath = await WriteOutputImageAsync(new MemoryStream(gridBytesWithMetadata), args, isGrid: true);
+            var gridPath = await WriteOutputImageAsync(
+                new MemoryStream(gridBytesWithMetadata),
+                args,
+                isGrid: true
+            );
 
             // Insert to start of images
-            var gridImage = new ImageSource(gridPath) { Label = imageLabel };
-
+            var gridImage = new ImageSource(gridPath);
             // Preload
             await gridImage.GetBitmapAsync();
             ImageGalleryCardViewModel.ImageSources.Add(gridImage);
@@ -465,7 +522,10 @@ public abstract partial class InferenceGenerationViewModelBase : InferenceTabVie
     /// <param name="options">Optional overrides (side buttons)</param>
     /// <param name="cancellationToken">Cancellation token</param>
     [RelayCommand(IncludeCancelCommand = true, FlowExceptionsToTaskScheduler = true)]
-    private async Task GenerateImage(GenerateFlags options = default, CancellationToken cancellationToken = default)
+    private async Task GenerateImage(
+        GenerateFlags options = default,
+        CancellationToken cancellationToken = default
+    )
     {
         var overrides = GenerateOverrides.FromFlags(options);
 
@@ -475,12 +535,7 @@ public abstract partial class InferenceGenerationViewModelBase : InferenceTabVie
         }
         catch (OperationCanceledException)
         {
-            Logger.Debug("Image Generation Canceled");
-        }
-        catch (ValidationException e)
-        {
-            Logger.Debug("Image Generation Validation Error: {Message}", e.Message);
-            notificationService.Show("Validation Error", e.Message, NotificationType.Error);
+            Logger.Debug($"Image Generation Canceled");
         }
     }
 
@@ -513,9 +568,7 @@ public abstract partial class InferenceGenerationViewModelBase : InferenceTabVie
     /// </summary>
     protected virtual void OnProgressUpdateReceived(object? sender, ComfyProgressUpdateEventArgs args)
     {
-        Dispatcher
-            .UIThread
-            .Post(() =>
+        Dispatcher.UIThread.Post(() =>
         {
             OutputProgress.Value = args.Value;
             OutputProgress.Maximum = args.Maximum;
@@ -548,9 +601,7 @@ public abstract partial class InferenceGenerationViewModelBase : InferenceTabVie
             return;
         }
 
-        Dispatcher
-            .UIThread
-            .Post(() =>
+        Dispatcher.UIThread.Post(() =>
         {
             OutputProgress.IsIndeterminate = true;
             OutputProgress.Value = 100;

StabilityMatrix.Avalonia/ViewModels/Base/LoadableViewModelBase.cs

@@ -28,24 +28,16 @@ public abstract class LoadableViewModelBase : ViewModelBase, IJsonLoadableState
 {
     private static readonly Logger Logger = LogManager.GetCurrentClassLogger();
 
-    private static readonly Type[] SerializerIgnoredTypes =
-    {
-        typeof(ICommand),
-        typeof(IRelayCommand)
-    };
+    private static readonly Type[] SerializerIgnoredTypes = { typeof(ICommand), typeof(IRelayCommand) };
 
     private static readonly string[] SerializerIgnoredNames = { nameof(HasErrors) };
 
-    private static readonly JsonSerializerOptions SerializerOptions =
-        new() { IgnoreReadOnlyProperties = true };
+    private static readonly JsonSerializerOptions SerializerOptions = new() { IgnoreReadOnlyProperties = true };
 
     private static bool ShouldIgnoreProperty(PropertyInfo property)
     {
         // Skip if read-only and not IJsonLoadableState
-        if (
-            property.SetMethod is null
-            && !typeof(IJsonLoadableState).IsAssignableFrom(property.PropertyType)
-        )
+        if (property.SetMethod is null && !typeof(IJsonLoadableState).IsAssignableFrom(property.PropertyType))
         {
             Logger.ConditionalTrace("Skipping {Property} - read-only", property.Name);
             return true;
@@ -107,11 +99,7 @@ public abstract class LoadableViewModelBase : ViewModelBase, IJsonLoadableState
     {
         // Get all of our properties using reflection
         var properties = GetType().GetProperties();
-        Logger.ConditionalTrace(
-            "Serializing {Type} with {Count} properties",
-            GetType(),
-            properties.Length
-        );
+        Logger.ConditionalTrace("Serializing {Type} with {Count} properties", GetType(), properties.Length);
 
         foreach (var property in properties)
         {
@@ -119,9 +107,7 @@ public abstract class LoadableViewModelBase : ViewModelBase, IJsonLoadableState
 
             // If JsonPropertyName provided, use that as the key
             if (
-                property
-                    .GetCustomAttributes(typeof(JsonPropertyNameAttribute), true)
-                    .FirstOrDefault()
+                property.GetCustomAttributes(typeof(JsonPropertyNameAttribute), true).FirstOrDefault()
                 is JsonPropertyNameAttribute jsonPropertyName
             )
             {
@@ -168,10 +154,7 @@ public abstract class LoadableViewModelBase : ViewModelBase, IJsonLoadableState
                 if (property.GetValue(this) is not IJsonLoadableState propertyValue)
                 {
                     // If null, it must have a default constructor
-                    if (
-                        property.PropertyType.GetConstructor(Type.EmptyTypes)
-                        is not { } constructorInfo
-                    )
+                    if (property.PropertyType.GetConstructor(Type.EmptyTypes) is not { } constructorInfo)
                     {
                         throw new InvalidOperationException(
                             $"Property {property.Name} is IJsonLoadableState but current object is null and has no default constructor"
@@ -188,11 +171,7 @@ public abstract class LoadableViewModelBase : ViewModelBase, IJsonLoadableState
             }
             else
             {
-                Logger.ConditionalTrace(
-                    "Loading {Property} ({Type})",
-                    property.Name,
-                    property.PropertyType
-                );
+                Logger.ConditionalTrace("Loading {Property} ({Type})", property.Name, property.PropertyType);
 
                 var propertyValue = value.Deserialize(property.PropertyType, SerializerOptions);
                 property.SetValue(this, propertyValue);
@@ -216,11 +195,7 @@ public abstract class LoadableViewModelBase : ViewModelBase, IJsonLoadableState
     {
         // Get all of our properties using reflection.
         var properties = GetType().GetProperties();
-        Logger.ConditionalTrace(
-            "Serializing {Type} with {Count} properties",
-            GetType(),
-            properties.Length
-        );
+        Logger.ConditionalTrace("Serializing {Type} with {Count} properties", GetType(), properties.Length);
 
         // Create a JSON object to store the state.
         var state = new JsonObject();
@@ -237,9 +212,7 @@ public abstract class LoadableViewModelBase : ViewModelBase, IJsonLoadableState
 
             // If JsonPropertyName provided, use that as the key.
             if (
-                property
-                    .GetCustomAttributes(typeof(JsonPropertyNameAttribute), true)
-                    .FirstOrDefault()
+                property.GetCustomAttributes(typeof(JsonPropertyNameAttribute), true).FirstOrDefault()
                 is JsonPropertyNameAttribute jsonPropertyName
             )
             {
@@ -270,11 +243,7 @@ public abstract class LoadableViewModelBase : ViewModelBase, IJsonLoadableState
             }
             else
             {
-                Logger.ConditionalTrace(
-                    "Serializing {Property} ({Type})",
-                    property.Name,
-                    property.PropertyType
-                );
+                Logger.ConditionalTrace("Serializing {Property} ({Type})", property.Name, property.PropertyType);
                 var value = property.GetValue(this);
                 if (value is not null)
                 {
@@ -297,8 +266,7 @@ public abstract class LoadableViewModelBase : ViewModelBase, IJsonLoadableState
     protected static JsonObject SerializeModel<T>(T model)
     {
         var node = JsonSerializer.SerializeToNode(model);
-        return node?.AsObject()
-            ?? throw new NullReferenceException("Failed to serialize state to JSON object.");
+        return node?.AsObject() ?? throw new NullReferenceException("Failed to serialize state to JSON object.");
     }
 
     /// <summary>

StabilityMatrix.Avalonia/ViewModels/CheckpointBrowser/CheckpointBrowserCardViewModel.cs

@@ -21,6 +21,7 @@ using StabilityMatrix.Core.Attributes;
 using StabilityMatrix.Core.Extensions;
 using StabilityMatrix.Core.Models;
 using StabilityMatrix.Core.Models.Api;
+using StabilityMatrix.Core.Models.Database;
 using StabilityMatrix.Core.Models.FileInterfaces;
 using StabilityMatrix.Core.Models.Progress;
 using StabilityMatrix.Core.Processes;
@@ -120,9 +121,7 @@ public partial class CheckpointBrowserCardViewModel : Base.ProgressViewModel
 
         var latestVersionInstalled =
             latestVersion.Files != null
-            && latestVersion
-                .Files
-                .Any(
+            && latestVersion.Files.Any(
                 file =>
                     file is { Type: CivitFileType.Model, Hashes.BLAKE3: not null }
                     && installedModels.Contains(file.Hashes.BLAKE3)
@@ -131,14 +130,10 @@ public partial class CheckpointBrowserCardViewModel : Base.ProgressViewModel
         // check if any of the ModelVersion.Files.Hashes.BLAKE3 hashes are in the installedModels list
         var anyVersionInstalled =
             latestVersionInstalled
-            || CivitModel
-                .ModelVersions
-                .Any(
+            || CivitModel.ModelVersions.Any(
                 version =>
                     version.Files != null
-                        && version
-                            .Files
-                            .Any(
+                    && version.Files.Any(
                         file =>
                             file is { Type: CivitFileType.Model, Hashes.BLAKE3: not null }
                             && installedModels.Contains(file.Hashes.BLAKE3)
@@ -154,7 +149,6 @@ public partial class CheckpointBrowserCardViewModel : Base.ProgressViewModel
         ShowUpdateCard = anyVersionInstalled;
     }
 
-    // Choose and load image based on nsfw setting
     private void UpdateImage()
     {
         var nsfwEnabled = settingsManager.Settings.ModelBrowserNsfwEnabled;
@@ -162,21 +156,17 @@ public partial class CheckpointBrowserCardViewModel : Base.ProgressViewModel
         var images = version?.Images;
 
         // Try to find a valid image
-        var image = images?.FirstOrDefault(image => nsfwEnabled || image.Nsfw == "None");
+        var image = images
+            ?.Where(img => LocalModelFile.SupportedImageExtensions.Any(img.Url.Contains))
+            .FirstOrDefault(image => nsfwEnabled || image.Nsfw == "None");
         if (image != null)
         {
-            // var imageStream = await downloadService.GetImageStreamFromUrl(image.Url);
-            // Dispatcher.UIThread.Post(() => { CardImage = new Bitmap(imageStream); });
             CardImage = new Uri(image.Url);
             return;
         }
 
         // If no valid image found, use no image
         CardImage = Assets.NoImage;
-
-        // var assetStream = AssetLoader.Open(new Uri("avares://StabilityMatrix.Avalonia/Assets/noimage.png"));
-        // Otherwise Default image
-        // Dispatcher.UIThread.Post(() => { CardImage = new Bitmap(assetStream); });
     }
 
     [RelayCommand]
@@ -270,8 +260,7 @@ public partial class CheckpointBrowserCardViewModel : Base.ProgressViewModel
     {
         var prunedDescription =
             model
-                .Description
-                ?.Replace("<br/>", $"{Environment.NewLine}{Environment.NewLine}")
+                .Description?.Replace("<br/>", $"{Environment.NewLine}{Environment.NewLine}")
                 .Replace("<br />", $"{Environment.NewLine}{Environment.NewLine}")
                 .Replace("</p>", $"{Environment.NewLine}{Environment.NewLine}")
                 .Replace("</h1>", $"{Environment.NewLine}{Environment.NewLine}")
@@ -318,9 +307,9 @@ public partial class CheckpointBrowserCardViewModel : Base.ProgressViewModel
         var imageExtension = Path.GetExtension(image.Url).TrimStart('.');
         if (imageExtension is "jpg" or "jpeg" or "png")
         {
-            var imageDownloadPath = modelFilePath
-                .Directory!
-                .JoinFile($"{modelFilePath.NameWithoutExtension}.preview.{imageExtension}");
+            var imageDownloadPath = modelFilePath.Directory!.JoinFile(
+                $"{modelFilePath.NameWithoutExtension}.preview.{imageExtension}"
+            );
 
             var imageTask = downloadService.DownloadToFileAsync(image.Url, imageDownloadPath);
             await notificationService.TryAsync(imageTask, "Could not download preview image");
@@ -358,7 +347,8 @@ public partial class CheckpointBrowserCardViewModel : Base.ProgressViewModel
         }
 
         // Get latest version file
-        var modelFile = selectedFile ?? modelVersion.Files?.FirstOrDefault(x => x.Type == CivitFileType.Model);
+        var modelFile =
+            selectedFile ?? modelVersion.Files?.FirstOrDefault(x => x.Type == CivitFileType.Model);
         if (modelFile is null)
         {
             notificationService.Show(
@@ -374,7 +364,9 @@ public partial class CheckpointBrowserCardViewModel : Base.ProgressViewModel
 
         var rootModelsDirectory = new DirectoryPath(settingsManager.ModelsDirectory);
 
-        var downloadDirectory = rootModelsDirectory.JoinDir(model.Type.ConvertTo<SharedFolderType>().GetStringValue());
+        var downloadDirectory = rootModelsDirectory.JoinDir(
+            model.Type.ConvertTo<SharedFolderType>().GetStringValue()
+        );
         // Folders might be missing if user didn't install any packages yet
         downloadDirectory.Create();
 

StabilityMatrix.Avalonia/ViewModels/ConsoleViewModel.cs

@@ -7,9 +7,9 @@ using System.Threading.Tasks.Dataflow;
 using Avalonia.Threading;
 using AvaloniaEdit.Document;
 using CommunityToolkit.Mvvm.ComponentModel;
+using NLog;
 using Nito.AsyncEx;
 using Nito.AsyncEx.Synchronous;
-using NLog;
 using StabilityMatrix.Core.Extensions;
 using StabilityMatrix.Core.Processes;
 

StabilityMatrix.Avalonia/ViewModels/Dialogs/SelectModelVersionViewModel.cs

@@ -90,9 +90,7 @@ public partial class SelectModelVersionViewModel : ContentDialogViewModelBase
             CanGoToNextImage = allImages.Count > 1;
         }
 
-        Dispatcher
-            .UIThread
-            .Post(() =>
+        Dispatcher.UIThread.Post(() =>
         {
             CanGoToPreviousImage = false;
             SelectedFile = SelectedVersionViewModel?.CivitFileViewModels.FirstOrDefault();

StabilityMatrix.Avalonia/ViewModels/Dialogs/UpdateViewModel.cs

@@ -126,10 +126,7 @@ public partial class UpdateViewModel : ContentDialogViewModelBase
 
         ShowProgressBar = true;
         IsProgressIndeterminate = true;
-        UpdateText = string.Format(
-            Resources.TextTemplate_UpdatingPackage,
-            Resources.Label_StabilityMatrix
-        );
+        UpdateText = string.Format(Resources.TextTemplate_UpdatingPackage, Resources.Label_StabilityMatrix);
 
         try
         {
@@ -173,10 +170,7 @@ public partial class UpdateViewModel : ContentDialogViewModelBase
         UpdateText = "Getting a few things ready...";
         await using (new MinimumDelay(500, 1000))
         {
-            Process.Start(
-                UpdateHelper.ExecutablePath,
-                $"--wait-for-exit-pid {Environment.ProcessId}"
-            );
+            Process.Start(UpdateHelper.ExecutablePath, $"--wait-for-exit-pid {Environment.ProcessId}");
         }
 
         UpdateText = "Update complete. Restarting Stability Matrix in 3 seconds...";
@@ -262,15 +256,10 @@ public partial class UpdateViewModel : ContentDialogViewModelBase
 
         // Join all blocks until and excluding the current version
         // If we're on a pre-release, include the current release
-        var currentVersionBlock = results.FindIndex(
-            x => x.Version == currentVersion.WithoutMetadata()
-        );
+        var currentVersionBlock = results.FindIndex(x => x.Version == currentVersion.WithoutMetadata());
 
         // For mismatching build metadata, add one
-        if (
-            currentVersionBlock != -1
-            && results[currentVersionBlock].Version?.Metadata != currentVersion.Metadata
-        )
+        if (currentVersionBlock != -1 && results[currentVersionBlock].Version?.Metadata != currentVersion.Metadata)
         {
             currentVersionBlock++;
         }
@@ -278,9 +267,7 @@ public partial class UpdateViewModel : ContentDialogViewModelBase
         // Support for previous pre-release without changelogs
         if (currentVersionBlock == -1)
         {
-            currentVersionBlock = results.FindIndex(
-                x => x.Version == currentVersion.WithoutPrereleaseOrMetadata()
-            );
+            currentVersionBlock = results.FindIndex(x => x.Version == currentVersion.WithoutPrereleaseOrMetadata());
 
             // Add 1 if found to include the current release
             if (currentVersionBlock != -1)

StabilityMatrix.Avalonia/ViewModels/Inference/InferenceImageToVideoViewModel.cs

@@ -0,0 +1,245 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Linq;
+using System.Text.Json.Nodes;
+using System.Text.Json.Serialization;
+using System.Threading;
+using System.Threading.Tasks;
+using CommunityToolkit.Mvvm.ComponentModel;
+using NLog;
+using StabilityMatrix.Avalonia.Models;
+using StabilityMatrix.Avalonia.Models.Inference;
+using StabilityMatrix.Avalonia.Services;
+using StabilityMatrix.Avalonia.ViewModels.Base;
+using StabilityMatrix.Avalonia.ViewModels.Inference.Video;
+using StabilityMatrix.Avalonia.Views.Inference;
+using StabilityMatrix.Core.Attributes;
+using StabilityMatrix.Core.Helper;
+using StabilityMatrix.Core.Models;
+using StabilityMatrix.Core.Models.Api.Comfy;
+using StabilityMatrix.Core.Models.Api.Comfy.Nodes;
+using StabilityMatrix.Core.Models.FileInterfaces;
+using StabilityMatrix.Core.Services;
+
+namespace StabilityMatrix.Avalonia.ViewModels.Inference;
+
+[View(typeof(InferenceImageToVideoView), persistent: true)]
+[ManagedService]
+[Transient]
+public partial class InferenceImageToVideoViewModel
+    : InferenceGenerationViewModelBase,
+        IParametersLoadableState
+{
+    private static readonly Logger Logger = LogManager.GetCurrentClassLogger();
+
+    private readonly INotificationService notificationService;
+    private readonly IModelIndexService modelIndexService;
+
+    [JsonIgnore]
+    public StackCardViewModel StackCardViewModel { get; }
+
+    [JsonPropertyName("Model")]
+    public ImgToVidModelCardViewModel ModelCardViewModel { get; }
+
+    [JsonPropertyName("Sampler")]
+    public SamplerCardViewModel SamplerCardViewModel { get; }
+
+    [JsonPropertyName("BatchSize")]
+    public BatchSizeCardViewModel BatchSizeCardViewModel { get; }
+
+    [JsonPropertyName("Seed")]
+    public SeedCardViewModel SeedCardViewModel { get; }
+
+    [JsonPropertyName("ImageLoader")]
+    public SelectImageCardViewModel SelectImageCardViewModel { get; }
+
+    [JsonPropertyName("Conditioning")]
+    public SvdImgToVidConditioningViewModel SvdImgToVidConditioningViewModel { get; }
+
+    [JsonPropertyName("VideoOutput")]
+    public VideoOutputSettingsCardViewModel VideoOutputSettingsCardViewModel { get; }
+
+    public InferenceImageToVideoViewModel(
+        INotificationService notificationService,
+        IInferenceClientManager inferenceClientManager,
+        ISettingsManager settingsManager,
+        ServiceManager<ViewModelBase> vmFactory,
+        IModelIndexService modelIndexService
+    )
+        : base(vmFactory, inferenceClientManager, notificationService, settingsManager)
+    {
+        this.notificationService = notificationService;
+        this.modelIndexService = modelIndexService;
+
+        // Get sub view models from service manager
+
+        SeedCardViewModel = vmFactory.Get<SeedCardViewModel>();
+        SeedCardViewModel.GenerateNewSeed();
+
+        ModelCardViewModel = vmFactory.Get<ImgToVidModelCardViewModel>();
+
+        SamplerCardViewModel = vmFactory.Get<SamplerCardViewModel>(samplerCard =>
+        {
+            samplerCard.IsDimensionsEnabled = true;
+            samplerCard.IsCfgScaleEnabled = true;
+            samplerCard.IsSamplerSelectionEnabled = true;
+            samplerCard.IsSchedulerSelectionEnabled = true;
+            samplerCard.CfgScale = 2.5d;
+            samplerCard.SelectedSampler = ComfySampler.Euler;
+            samplerCard.SelectedScheduler = ComfyScheduler.Karras;
+            samplerCard.IsDenoiseStrengthEnabled = true;
+            samplerCard.DenoiseStrength = 1.0f;
+        });
+
+        BatchSizeCardViewModel = vmFactory.Get<BatchSizeCardViewModel>();
+
+        SelectImageCardViewModel = vmFactory.Get<SelectImageCardViewModel>();
+        SvdImgToVidConditioningViewModel = vmFactory.Get<SvdImgToVidConditioningViewModel>();
+        VideoOutputSettingsCardViewModel = vmFactory.Get<VideoOutputSettingsCardViewModel>();
+
+        StackCardViewModel = vmFactory.Get<StackCardViewModel>();
+        StackCardViewModel.AddCards(
+            ModelCardViewModel,
+            SvdImgToVidConditioningViewModel,
+            SamplerCardViewModel,
+            SeedCardViewModel,
+            VideoOutputSettingsCardViewModel,
+            BatchSizeCardViewModel
+        );
+    }
+
+    /// <inheritdoc />
+    protected override void BuildPrompt(BuildPromptEventArgs args)
+    {
+        base.BuildPrompt(args);
+
+        var builder = args.Builder;
+
+        builder.Connections.Seed = args.SeedOverride switch
+        {
+            { } seed => Convert.ToUInt64(seed),
+            _ => Convert.ToUInt64(SeedCardViewModel.Seed)
+        };
+
+        // Load models
+        ModelCardViewModel.ApplyStep(args);
+
+        // Setup latent from image
+        var imageLoad = builder.Nodes.AddTypedNode(
+            new ComfyNodeBuilder.LoadImage
+            {
+                Name = builder.Nodes.GetUniqueName("ControlNet_LoadImage"),
+                Image =
+                    SelectImageCardViewModel.ImageSource?.GetHashGuidFileNameCached("Inference")
+                    ?? throw new ValidationException()
+            }
+        );
+        builder.Connections.Primary = imageLoad.Output1;
+        builder.Connections.PrimarySize = SelectImageCardViewModel.CurrentBitmapSize;
+
+        // Setup img2vid stuff
+        // Set width & height from SamplerCard
+        SvdImgToVidConditioningViewModel.Width = SamplerCardViewModel.Width;
+        SvdImgToVidConditioningViewModel.Height = SamplerCardViewModel.Height;
+        SvdImgToVidConditioningViewModel.ApplyStep(args);
+
+        // Setup Sampler and Refiner if enabled
+        SamplerCardViewModel.ApplyStep(args);
+
+        // Animated webp output
+        VideoOutputSettingsCardViewModel.ApplyStep(args);
+    }
+
+    /// <inheritdoc />
+    protected override IEnumerable<ImageSource> GetInputImages()
+    {
+        if (SelectImageCardViewModel.ImageSource is { } image)
+        {
+            yield return image;
+        }
+    }
+
+    /// <inheritdoc />
+    protected override async Task GenerateImageImpl(
+        GenerateOverrides overrides,
+        CancellationToken cancellationToken
+    )
+    {
+        if (!await CheckClientConnectedWithPrompt() || !ClientManager.IsConnected)
+        {
+            return;
+        }
+
+        // If enabled, randomize the seed
+        var seedCard = StackCardViewModel.GetCard<SeedCardViewModel>();
+        if (overrides is not { UseCurrentSeed: true } && seedCard.IsRandomizeEnabled)
+        {
+            seedCard.GenerateNewSeed();
+        }
+
+        var batches = BatchSizeCardViewModel.BatchCount;
+
+        var batchArgs = new List<ImageGenerationEventArgs>();
+
+        for (var i = 0; i < batches; i++)
+        {
+            var seed = seedCard.Seed + i;
+
+            var buildPromptArgs = new BuildPromptEventArgs { Overrides = overrides, SeedOverride = seed };
+            BuildPrompt(buildPromptArgs);
+
+            var generationArgs = new ImageGenerationEventArgs
+            {
+                Client = ClientManager.Client,
+                Nodes = buildPromptArgs.Builder.ToNodeDictionary(),
+                OutputNodeNames = buildPromptArgs.Builder.Connections.OutputNodeNames.ToArray(),
+                Parameters = SaveStateToParameters(new GenerationParameters()),
+                Project = InferenceProjectDocument.FromLoadable(this),
+                // Only clear output images on the first batch
+                ClearOutputImages = i == 0
+            };
+
+            batchArgs.Add(generationArgs);
+        }
+
+        // Run batches
+        foreach (var args in batchArgs)
+        {
+            await RunGeneration(args, cancellationToken);
+        }
+    }
+
+    /// <inheritdoc />
+    public void LoadStateFromParameters(GenerationParameters parameters)
+    {
+        SamplerCardViewModel.LoadStateFromParameters(parameters);
+        ModelCardViewModel.LoadStateFromParameters(parameters);
+        SvdImgToVidConditioningViewModel.LoadStateFromParameters(parameters);
+        VideoOutputSettingsCardViewModel.LoadStateFromParameters(parameters);
+
+        SeedCardViewModel.Seed = Convert.ToInt64(parameters.Seed);
+    }
+
+    /// <inheritdoc />
+    public GenerationParameters SaveStateToParameters(GenerationParameters parameters)
+    {
+        parameters = SamplerCardViewModel.SaveStateToParameters(parameters);
+        parameters = ModelCardViewModel.SaveStateToParameters(parameters);
+        parameters = SvdImgToVidConditioningViewModel.SaveStateToParameters(parameters);
+        parameters = VideoOutputSettingsCardViewModel.SaveStateToParameters(parameters);
+
+        parameters.Seed = (ulong)SeedCardViewModel.Seed;
+
+        return parameters;
+    }
+
+    // Migration for v2 deserialization
+    public override void LoadStateFromJsonObject(JsonObject state, int version)
+    {
+        if (version > 2)
+        {
+            LoadStateFromJsonObject(state);
+        }
+    }
+}

StabilityMatrix.Avalonia/ViewModels/Inference/InferenceImageUpscaleViewModel.cs

@@ -107,9 +107,7 @@ public class InferenceImageUpscaleViewModel : InferenceGenerationViewModelBase
         // If upscale is enabled, add another upscale group
         if (IsUpscaleEnabled)
         {
-            var upscaleSize = builder.Connections.PrimarySize.WithScale(
-                UpscalerCardViewModel.Scale
-            );
+            var upscaleSize = builder.Connections.PrimarySize.WithScale(UpscalerCardViewModel.Scale);
 
             // Build group
             builder.Connections.Primary = builder
@@ -144,10 +142,7 @@ public class InferenceImageUpscaleViewModel : InferenceGenerationViewModelBase
     }
 
     /// <inheritdoc />
-    protected override async Task GenerateImageImpl(
-        GenerateOverrides overrides,
-        CancellationToken cancellationToken
-    )
+    protected override async Task GenerateImageImpl(GenerateOverrides overrides, CancellationToken cancellationToken)
     {
         if (!ClientManager.IsConnected)
         {
@@ -174,10 +169,7 @@ public class InferenceImageUpscaleViewModel : InferenceGenerationViewModelBase
             Client = ClientManager.Client,
             Nodes = buildPromptArgs.Builder.ToNodeDictionary(),
             OutputNodeNames = buildPromptArgs.Builder.Connections.OutputNodeNames.ToArray(),
-            Parameters = new GenerationParameters
-            {
-                ModelName = UpscalerCardViewModel.SelectedUpscaler?.Name,
-            },
+            Parameters = new GenerationParameters { ModelName = UpscalerCardViewModel.SelectedUpscaler?.Name, },
             Project = InferenceProjectDocument.FromLoadable(this)
         };
 

StabilityMatrix.Avalonia/ViewModels/Inference/InferenceTextToImageViewModel.cs

@@ -162,18 +162,21 @@ public class InferenceTextToImageViewModel : InferenceGenerationViewModelBase, I
     protected override IEnumerable<ImageSource> GetInputImages()
     {
         var samplerImages = SamplerCardViewModel
-            .ModulesCardViewModel
-            .Cards
-            .OfType<IInputImageProvider>()
+            .ModulesCardViewModel.Cards.OfType<IInputImageProvider>()
             .SelectMany(m => m.GetInputImages());
 
-        var moduleImages = ModulesCardViewModel.Cards.OfType<IInputImageProvider>().SelectMany(m => m.GetInputImages());
+        var moduleImages = ModulesCardViewModel
+            .Cards.OfType<IInputImageProvider>()
+            .SelectMany(m => m.GetInputImages());
 
         return samplerImages.Concat(moduleImages);
     }
 
     /// <inheritdoc />
-    protected override async Task GenerateImageImpl(GenerateOverrides overrides, CancellationToken cancellationToken)
+    protected override async Task GenerateImageImpl(
+        GenerateOverrides overrides,
+        CancellationToken cancellationToken
+    )
     {
         // Validate the prompts
         if (!await PromptCardViewModel.ValidatePrompts())
@@ -267,12 +270,16 @@ public class InferenceTextToImageViewModel : InferenceGenerationViewModelBase, I
 
                 if (state.TryGetPropertyValue("HiresSampler", out var hiresSamplerState))
                 {
-                    module.GetCard<SamplerCardViewModel>().LoadStateFromJsonObject(hiresSamplerState!.AsObject());
+                    module
+                        .GetCard<SamplerCardViewModel>()
+                        .LoadStateFromJsonObject(hiresSamplerState!.AsObject());
                 }
 
                 if (state.TryGetPropertyValue("HiresUpscaler", out var hiresUpscalerState))
                 {
-                    module.GetCard<UpscalerCardViewModel>().LoadStateFromJsonObject(hiresUpscalerState!.AsObject());
+                    module
+                        .GetCard<UpscalerCardViewModel>()
+                        .LoadStateFromJsonObject(hiresUpscalerState!.AsObject());
                 }
             });
 
@@ -282,14 +289,14 @@ public class InferenceTextToImageViewModel : InferenceGenerationViewModelBase, I
 
                 if (state.TryGetPropertyValue("Upscaler", out var upscalerState))
                 {
-                    module.GetCard<UpscalerCardViewModel>().LoadStateFromJsonObject(upscalerState!.AsObject());
+                    module
+                        .GetCard<UpscalerCardViewModel>()
+                        .LoadStateFromJsonObject(upscalerState!.AsObject());
                 }
             });
 
             // Add FreeU to sampler
-            SamplerCardViewModel
-                .ModulesCardViewModel
-                .AddModule<FreeUModule>(module =>
+            SamplerCardViewModel.ModulesCardViewModel.AddModule<FreeUModule>(module =>
             {
                 module.IsEnabled = state.GetPropertyValueOrDefault<bool>("IsFreeUEnabled");
             });

StabilityMatrix.Avalonia/ViewModels/Inference/ModelCardViewModel.cs

@@ -38,45 +38,54 @@ public partial class ModelCardViewModel(IInferenceClientManager clientManager)
     [ObservableProperty]
     private bool isVaeSelectionEnabled;
 
+    [ObservableProperty]
+    private bool disableSettings;
+
+    [ObservableProperty]
+    private bool isClipSkipEnabled;
+
+    [NotifyDataErrorInfo]
+    [ObservableProperty]
+    [Range(1, 24)]
+    private int clipSkip = 1;
+
     public IInferenceClientManager ClientManager { get; } = clientManager;
 
     /// <inheritdoc />
-    public void ApplyStep(ModuleApplyStepEventArgs e)
+    public virtual void ApplyStep(ModuleApplyStepEventArgs e)
     {
         // Load base checkpoint
         var baseLoader = e.Nodes.AddTypedNode(
             new ComfyNodeBuilder.CheckpointLoaderSimple
             {
-                Name = "CheckpointLoader",
-                CkptName =
-                    SelectedModel?.RelativePath
-                    ?? throw new ValidationException("Model not selected")
+                Name = "CheckpointLoader_Base",
+                CkptName = SelectedModel?.RelativePath ?? throw new ValidationException("Model not selected")
             }
         );
 
-        e.Builder.Connections.BaseModel = baseLoader.Output1;
-        e.Builder.Connections.BaseClip = baseLoader.Output2;
-        e.Builder.Connections.BaseVAE = baseLoader.Output3;
+        e.Builder.Connections.Base.Model = baseLoader.Output1;
+        e.Builder.Connections.Base.Clip = baseLoader.Output2;
+        e.Builder.Connections.Base.VAE = baseLoader.Output3;
 
-        // Load refiner
+        // Load refiner if enabled
         if (IsRefinerSelectionEnabled && SelectedRefiner is { IsNone: false })
         {
             var refinerLoader = e.Nodes.AddTypedNode(
                 new ComfyNodeBuilder.CheckpointLoaderSimple
                 {
-                    Name = "Refiner_CheckpointLoader",
+                    Name = "CheckpointLoader_Refiner",
                     CkptName =
                         SelectedRefiner?.RelativePath
                         ?? throw new ValidationException("Refiner Model enabled but not selected")
                 }
             );
 
-            e.Builder.Connections.RefinerModel = refinerLoader.Output1;
-            e.Builder.Connections.RefinerClip = refinerLoader.Output2;
-            e.Builder.Connections.RefinerVAE = refinerLoader.Output3;
+            e.Builder.Connections.Refiner.Model = refinerLoader.Output1;
+            e.Builder.Connections.Refiner.Clip = refinerLoader.Output2;
+            e.Builder.Connections.Refiner.VAE = refinerLoader.Output3;
         }
 
-        // Load custom VAE
+        // Load VAE override if enabled
         if (IsVaeSelectionEnabled && SelectedVae is { IsNone: false, IsDefault: false })
         {
             var vaeLoader = e.Nodes.AddTypedNode(
@@ -91,6 +100,28 @@ public partial class ModelCardViewModel(IInferenceClientManager clientManager)
 
             e.Builder.Connections.PrimaryVAE = vaeLoader.Output;
         }
+
+        // Clip skip all models if enabled
+        if (IsClipSkipEnabled)
+        {
+            foreach (var (modelName, model) in e.Builder.Connections.Models)
+            {
+                if (model.Clip is not { } modelClip)
+                    continue;
+
+                var clipSetLastLayer = e.Nodes.AddTypedNode(
+                    new ComfyNodeBuilder.CLIPSetLastLayer
+                    {
+                        Name = $"CLIP_Skip_{modelName}",
+                        Clip = modelClip,
+                        // Need to convert to negative indexing from (1 to 24) to (-1 to -24)
+                        StopAtClipLayer = -ClipSkip
+                    }
+                );
+
+                model.Clip = clipSetLastLayer.Output;
+            }
+        }
     }
 
     /// <inheritdoc />
@@ -102,8 +133,10 @@ public partial class ModelCardViewModel(IInferenceClientManager clientManager)
                 SelectedModelName = SelectedModel?.RelativePath,
                 SelectedVaeName = SelectedVae?.RelativePath,
                 SelectedRefinerName = SelectedRefiner?.RelativePath,
+                ClipSkip = ClipSkip,
                 IsVaeSelectionEnabled = IsVaeSelectionEnabled,
-                IsRefinerSelectionEnabled = IsRefinerSelectionEnabled
+                IsRefinerSelectionEnabled = IsRefinerSelectionEnabled,
+                IsClipSkipEnabled = IsClipSkipEnabled
             }
         );
     }
@@ -125,8 +158,11 @@ public partial class ModelCardViewModel(IInferenceClientManager clientManager)
             ? HybridModelFile.None
             : ClientManager.Models.FirstOrDefault(x => x.RelativePath == model.SelectedRefinerName);
 
+        ClipSkip = model.ClipSkip;
+
         IsVaeSelectionEnabled = model.IsVaeSelectionEnabled;
         IsRefinerSelectionEnabled = model.IsRefinerSelectionEnabled;
+        IsClipSkipEnabled = model.IsClipSkipEnabled;
     }
 
     /// <inheritdoc />
@@ -145,19 +181,14 @@ public partial class ModelCardViewModel(IInferenceClientManager clientManager)
             model = currentModels.FirstOrDefault(
                 m =>
                     m.Local?.ConnectedModelInfo?.Hashes.SHA256 is { } sha256
-                    && sha256.StartsWith(
-                        parameters.ModelHash,
-                        StringComparison.InvariantCultureIgnoreCase
-                    )
+                    && sha256.StartsWith(parameters.ModelHash, StringComparison.InvariantCultureIgnoreCase)
             );
         }
         else
         {
             // Name matches
             model = currentModels.FirstOrDefault(m => m.RelativePath.EndsWith(paramsModelName));
-            model ??= currentModels.FirstOrDefault(
-                m => m.ShortDisplayName.StartsWith(paramsModelName)
-            );
+            model ??= currentModels.FirstOrDefault(m => m.ShortDisplayName.StartsWith(paramsModelName));
         }
 
         if (model is not null)
@@ -181,8 +212,10 @@ public partial class ModelCardViewModel(IInferenceClientManager clientManager)
         public string? SelectedModelName { get; init; }
         public string? SelectedRefinerName { get; init; }
         public string? SelectedVaeName { get; init; }
+        public int ClipSkip { get; init; } = 1;
 
         public bool IsVaeSelectionEnabled { get; init; }
         public bool IsRefinerSelectionEnabled { get; init; }
+        public bool IsClipSkipEnabled { get; init; }
     }
 }

StabilityMatrix.Avalonia/ViewModels/Inference/Modules/ControlNetModule.cs

@@ -1,8 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
-using System.Linq;
-using StabilityMatrix.Avalonia.Controls;
 using StabilityMatrix.Avalonia.Models;
 using StabilityMatrix.Avalonia.Models.Inference;
 using StabilityMatrix.Avalonia.Services;
@@ -81,8 +79,8 @@ public class ControlNetModule : ModuleBase
                     Name = e.Nodes.GetUniqueName("Refiner_ControlNetApply"),
                     Image = imageLoad.Output1,
                     ControlNet = controlNetLoader.Output,
-                    Positive = e.Temp.RefinerConditioning.Value.Positive,
-                    Negative = e.Temp.RefinerConditioning.Value.Negative,
+                    Positive = e.Temp.RefinerConditioning.Positive,
+                    Negative = e.Temp.RefinerConditioning.Negative,
                     Strength = card.Strength,
                     StartPercent = card.StartPercent,
                     EndPercent = card.EndPercent,

StabilityMatrix.Avalonia/ViewModels/Inference/Modules/FreeUModule.cs

@@ -1,7 +1,9 @@
-using StabilityMatrix.Avalonia.Models.Inference;
+using System.Linq;
+using StabilityMatrix.Avalonia.Models.Inference;
 using StabilityMatrix.Avalonia.Services;
 using StabilityMatrix.Avalonia.ViewModels.Base;
 using StabilityMatrix.Core.Attributes;
+using StabilityMatrix.Core.Extensions;
 using StabilityMatrix.Core.Models.Api.Comfy.Nodes;
 
 namespace StabilityMatrix.Avalonia.ViewModels.Inference.Modules;
@@ -25,34 +27,17 @@ public class FreeUModule : ModuleBase
     {
         var card = GetCard<FreeUCardViewModel>();
 
-        // Currently applies to both base and refiner model
+        // Currently applies to all models
         // TODO: Add option to apply to either base or refiner
 
-        if (e.Builder.Connections.BaseModel is not null)
+        foreach (var modelConnections in e.Builder.Connections.Models.Values.Where(m => m.Model is not null))
         {
-            e.Builder.Connections.BaseModel = e.Nodes
+            modelConnections.Model = e.Nodes
                 .AddTypedNode(
                     new ComfyNodeBuilder.FreeU
                     {
-                        Name = e.Nodes.GetUniqueName("FreeU"),
-                        Model = e.Builder.Connections.BaseModel,
-                        B1 = card.B1,
-                        B2 = card.B2,
-                        S1 = card.S1,
-                        S2 = card.S2
-                    }
-                )
-                .Output;
-        }
-
-        if (e.Builder.Connections.RefinerModel is not null)
-        {
-            e.Builder.Connections.RefinerModel = e.Nodes
-                .AddTypedNode(
-                    new ComfyNodeBuilder.FreeU
-                    {
-                        Name = e.Nodes.GetUniqueName("Refiner_FreeU"),
-                        Model = e.Builder.Connections.RefinerModel,
+                        Name = e.Nodes.GetUniqueName($"FreeU_{modelConnections.Name}"),
+                        Model = modelConnections.Model!,
                         B1 = card.B1,
                         B2 = card.B2,
                         S1 = card.S1,

StabilityMatrix.Avalonia/ViewModels/Inference/Modules/HiresFixModule.cs

@@ -1,10 +1,7 @@
 using System;
-using System.Collections.Generic;
-using System.ComponentModel;
 using System.Linq;
 using System.Threading.Tasks;
 using CommunityToolkit.Mvvm.Input;
-using StabilityMatrix.Avalonia.Controls;
 using StabilityMatrix.Avalonia.Languages;
 using StabilityMatrix.Avalonia.Models.Inference;
 using StabilityMatrix.Avalonia.Services;
@@ -73,7 +70,7 @@ public partial class HiresFixModule : ModuleBase
         {
             builder.Connections.Primary = builder.Group_Upscale(
                 builder.Nodes.GetUniqueName("HiresFix"),
-                builder.Connections.Primary ?? throw new ArgumentException("No Primary"),
+                builder.Connections.Primary.Unwrap(),
                 builder.Connections.GetDefaultVAE(),
                 selectedUpscaler,
                 hiresSize.Width,
@@ -99,8 +96,8 @@ public partial class HiresFixModule : ModuleBase
                         samplerCard.SelectedScheduler?.Name
                         ?? e.Builder.Connections.PrimaryScheduler?.Name
                         ?? throw new ArgumentException("No PrimaryScheduler"),
-                    Positive = builder.Connections.GetRefinerOrBaseConditioning(),
-                    Negative = builder.Connections.GetRefinerOrBaseNegativeConditioning(),
+                    Positive = builder.Connections.GetRefinerOrBaseConditioning().Positive,
+                    Negative = builder.Connections.GetRefinerOrBaseConditioning().Negative,
                     LatentImage = builder.GetPrimaryAsLatent(),
                     Denoise = samplerCard.DenoiseStrength
                 }

StabilityMatrix.Avalonia/ViewModels/Inference/PromptCardViewModel.cs

@@ -18,6 +18,7 @@ using StabilityMatrix.Core.Attributes;
 using StabilityMatrix.Core.Exceptions;
 using StabilityMatrix.Core.Helper.Cache;
 using StabilityMatrix.Core.Models;
+using StabilityMatrix.Core.Models.Api.Comfy.NodeTypes;
 using StabilityMatrix.Core.Models.Api.Comfy.Nodes;
 using StabilityMatrix.Core.Services;
 
@@ -26,10 +27,7 @@ namespace StabilityMatrix.Avalonia.ViewModels.Inference;
 [View(typeof(PromptCard))]
 [ManagedService]
 [Transient]
-public partial class PromptCardViewModel
-    : LoadableViewModelBase,
-        IParametersLoadableState,
-        IComfyStep
+public partial class PromptCardViewModel : LoadableViewModelBase, IParametersLoadableState, IComfyStep
 {
     private readonly IModelIndexService modelIndexService;
 
@@ -74,13 +72,11 @@ public partial class PromptCardViewModel
     /// Applies the prompt step.
     /// Requires:
     /// <list type="number">
-    /// <item><see cref="ComfyNodeBuilder.NodeBuilderConnections.BaseModel"/></item>
-    /// <item><see cref="ComfyNodeBuilder.NodeBuilderConnections.BaseClip"/></item>
+    /// <item><see cref="ComfyNodeBuilder.NodeBuilderConnections.Base"/> - Model, Clip</item>
     /// </list>
     /// Provides:
     /// <list type="number">
-    /// <item><see cref="ComfyNodeBuilder.NodeBuilderConnections.BaseConditioning"/></item>
-    /// <item><see cref="ComfyNodeBuilder.NodeBuilderConnections.BaseNegativeConditioning"/></item>
+    /// <item><see cref="ComfyNodeBuilder.NodeBuilderConnections.Base"/> - Conditioning</item>
     /// </list>
     /// </summary>
     public void ApplyStep(ModuleApplyStepEventArgs e)
@@ -91,90 +87,44 @@ public partial class PromptCardViewModel
         var negativePrompt = GetNegativePrompt();
         negativePrompt.Process();
 
+        foreach (var modelConnections in e.Builder.Connections.Models.Values)
+        {
+            if (modelConnections.Model is not { } model || modelConnections.Clip is not { } clip)
+                continue;
+
             // If need to load loras, add a group
             if (positivePrompt.ExtraNetworks.Count > 0)
             {
                 var loras = positivePrompt.GetExtraNetworksAsLocalModels(modelIndexService).ToList();
-            // Add group to load loras onto model and clip in series
-            var lorasGroup = e.Builder.Group_LoraLoadMany(
-                "Loras",
-                e.Builder.Connections.BaseModel ?? throw new ArgumentException("BaseModel is null"),
-                e.Builder.Connections.BaseClip ?? throw new ArgumentException("BaseClip is null"),
-                loras
-            );
 
-            // Set last outputs as base model and clip
-            e.Builder.Connections.BaseModel = lorasGroup.Output1;
-            e.Builder.Connections.BaseClip = lorasGroup.Output2;
-
-            // Refiner loras
-            if (e.Builder.Connections.RefinerModel is not null)
-            {
-                // Add group to load loras onto refiner model and clip in series
-                var lorasGroupRefiner = e.Builder.Group_LoraLoadMany(
-                    "Refiner_Loras",
-                    e.Builder.Connections.RefinerModel
-                        ?? throw new ArgumentException("RefinerModel is null"),
-                    e.Builder.Connections.RefinerClip
-                        ?? throw new ArgumentException("RefinerClip is null"),
-                    loras
-                );
+                // Add group to load loras onto model and clip in series
+                var lorasGroup = e.Builder.Group_LoraLoadMany($"Loras_{modelConnections.Name}", model, clip, loras);
 
-                // Set last outputs as refiner model and clip
-                e.Builder.Connections.RefinerModel = lorasGroupRefiner.Output1;
-                e.Builder.Connections.RefinerClip = lorasGroupRefiner.Output2;
-            }
+                // Set last outputs as model and clip
+                modelConnections.Model = lorasGroup.Output1;
+                modelConnections.Clip = lorasGroup.Output2;
             }
 
             // Clips
-        var positiveClip = e.Builder.Nodes.AddTypedNode(
+            var positiveClip = e.Nodes.AddTypedNode(
                 new ComfyNodeBuilder.CLIPTextEncode
                 {
-                Name = "PositiveCLIP",
-                Clip = e.Builder.Connections.BaseClip!,
+                    Name = $"PositiveCLIP_{modelConnections.Name}",
+                    Clip = e.Builder.Connections.Base.Clip!,
                     Text = positivePrompt.ProcessedText
                 }
             );
-        var negativeClip = e.Builder.Nodes.AddTypedNode(
+            var negativeClip = e.Nodes.AddTypedNode(
                 new ComfyNodeBuilder.CLIPTextEncode
                 {
-                Name = "NegativeCLIP",
-                Clip = e.Builder.Connections.BaseClip!,
+                    Name = $"NegativeCLIP_{modelConnections.Name}",
+                    Clip = e.Builder.Connections.Base.Clip!,
                     Text = negativePrompt.ProcessedText
                 }
             );
 
-        // Set base conditioning from Clips
-        e.Builder.Connections.BaseConditioning = positiveClip.Output;
-        e.Builder.Connections.BaseNegativeConditioning = negativeClip.Output;
-
-        // Refiner Clips
-        if (e.Builder.Connections.RefinerModel is not null)
-        {
-            var positiveClipRefiner = e.Builder.Nodes.AddTypedNode(
-                new ComfyNodeBuilder.CLIPTextEncode
-                {
-                    Name = "Refiner_PositiveCLIP",
-                    Clip =
-                        e.Builder.Connections.RefinerClip
-                        ?? throw new ArgumentException("RefinerClip is null"),
-                    Text = positivePrompt.ProcessedText
-                }
-            );
-            var negativeClipRefiner = e.Builder.Nodes.AddTypedNode(
-                new ComfyNodeBuilder.CLIPTextEncode
-                {
-                    Name = "Refiner_NegativeCLIP",
-                    Clip =
-                        e.Builder.Connections.RefinerClip
-                        ?? throw new ArgumentException("RefinerClip is null"),
-                    Text = negativePrompt.ProcessedText
-                }
-            );
-
-            // Set refiner conditioning from Clips
-            e.Builder.Connections.RefinerConditioning = positiveClipRefiner.Output;
-            e.Builder.Connections.RefinerNegativeConditioning = negativeClipRefiner.Output;
+            // Set conditioning from Clips
+            modelConnections.Conditioning = (positiveClip.Output, negativeClip.Output);
         }
     }
 
@@ -283,11 +233,7 @@ public partial class PromptCardViewModel
                   ```
                   """;
 
-        var dialog = DialogHelper.CreateMarkdownDialog(
-            md,
-            "Prompt Syntax",
-            TextEditorPreset.Prompt
-        );
+        var dialog = DialogHelper.CreateMarkdownDialog(md, "Prompt Syntax", TextEditorPreset.Prompt);
         dialog.MinDialogWidth = 800;
         dialog.MaxDialogHeight = 1000;
         dialog.MaxDialogWidth = 1000;
@@ -305,9 +251,7 @@ public partial class PromptCardViewModel
         }
         catch (PromptError e)
         {
-            await DialogHelper
-                .CreatePromptErrorDialog(e, prompt.RawText, modelIndexService)
-                .ShowAsync();
+            await DialogHelper.CreatePromptErrorDialog(e, prompt.RawText, modelIndexService).ShowAsync();
             return;
         }
 
@@ -327,10 +271,7 @@ public partial class PromptCardViewModel
                 builder.AppendLine($"## Networks ({networks.Count}):");
                 builder.AppendLine("```csharp");
                 builder.AppendLine(
-                    JsonSerializer.Serialize(
-                        networks,
-                        new JsonSerializerOptions() { WriteIndented = true, }
-                    )
+                    JsonSerializer.Serialize(networks, new JsonSerializerOptions() { WriteIndented = true, })
                 );
                 builder.AppendLine("```");
             }
@@ -378,11 +319,7 @@ public partial class PromptCardViewModel
     public override JsonObject SaveStateToJsonObject()
     {
         return SerializeModel(
-            new PromptCardModel
-            {
-                Prompt = PromptDocument.Text,
-                NegativePrompt = NegativePromptDocument.Text
-            }
+            new PromptCardModel { Prompt = PromptDocument.Text, NegativePrompt = NegativePromptDocument.Text }
         );
     }
 
@@ -405,10 +342,6 @@ public partial class PromptCardViewModel
     /// <inheritdoc />
     public GenerationParameters SaveStateToParameters(GenerationParameters parameters)
     {
-        return parameters with
-        {
-            PositivePrompt = PromptDocument.Text,
-            NegativePrompt = NegativePromptDocument.Text
-        };
+        return parameters with { PositivePrompt = PromptDocument.Text, NegativePrompt = NegativePromptDocument.Text };
     }
 }

StabilityMatrix.Avalonia/ViewModels/Inference/SamplerCardViewModel.cs

@@ -12,6 +12,7 @@ using StabilityMatrix.Avalonia.Services;
 using StabilityMatrix.Avalonia.ViewModels.Base;
 using StabilityMatrix.Avalonia.ViewModels.Inference.Modules;
 using StabilityMatrix.Core.Attributes;
+using StabilityMatrix.Core.Extensions;
 using StabilityMatrix.Core.Helper;
 using StabilityMatrix.Core.Models;
 using StabilityMatrix.Core.Models.Api.Comfy;
@@ -116,14 +117,8 @@ public partial class SamplerCardViewModel : LoadableViewModelBase, IParametersLo
         }
 
         // Provide temp values
-        e.Temp.Conditioning = (
-            e.Builder.Connections.BaseConditioning!,
-            e.Builder.Connections.BaseNegativeConditioning!
-        );
-        e.Temp.RefinerConditioning = (
-            e.Builder.Connections.RefinerConditioning!,
-            e.Builder.Connections.RefinerNegativeConditioning!
-        );
+        e.Temp.Conditioning = e.Builder.Connections.Base.Conditioning;
+        e.Temp.RefinerConditioning = e.Builder.Connections.Refiner.Conditioning;
 
         // Apply steps from our addons
         ApplyAddonSteps(e);
@@ -147,15 +142,17 @@ public partial class SamplerCardViewModel : LoadableViewModelBase, IParametersLo
         var primaryLatent = e.Builder.GetPrimaryAsLatent();
 
         // Set primary sampler and scheduler
-        e.Builder.Connections.PrimarySampler = SelectedSampler ?? throw new ValidationException("Sampler not selected");
-        e.Builder.Connections.PrimaryScheduler =
-            SelectedScheduler ?? throw new ValidationException("Scheduler not selected");
+        var primarySampler = SelectedSampler ?? throw new ValidationException("Sampler not selected");
+        e.Builder.Connections.PrimarySampler = primarySampler;
+
+        var primaryScheduler = SelectedScheduler ?? throw new ValidationException("Scheduler not selected");
+        e.Builder.Connections.PrimaryScheduler = primaryScheduler;
 
         // Use custom sampler if SDTurbo scheduler is selected
         if (e.Builder.Connections.PrimaryScheduler == ComfyScheduler.SDTurbo)
         {
             // Error if using refiner
-            if (e.Builder.Connections.RefinerModel is not null)
+            if (e.Builder.Connections.Refiner.Model is not null)
             {
                 throw new ValidationException("SDTurbo Scheduler cannot be used with Refiner Model");
             }
@@ -172,7 +169,7 @@ public partial class SamplerCardViewModel : LoadableViewModelBase, IParametersLo
                 new ComfyNodeBuilder.SDTurboScheduler
                 {
                     Name = "SDTurboScheduler",
-                    Model = e.Builder.Connections.BaseModel ?? throw new ArgumentException("No BaseModel"),
+                    Model = e.Builder.Connections.Base.Model.Unwrap(),
                     Steps = Steps
                 }
             );
@@ -181,7 +178,7 @@ public partial class SamplerCardViewModel : LoadableViewModelBase, IParametersLo
                 new ComfyNodeBuilder.SamplerCustom
                 {
                     Name = "Sampler",
-                    Model = e.Builder.Connections.BaseModel ?? throw new ArgumentException("No BaseModel"),
+                    Model = e.Builder.Connections.Base.Model,
                     AddNoise = true,
                     NoiseSeed = e.Builder.Connections.Seed,
                     Cfg = CfgScale,
@@ -199,21 +196,23 @@ public partial class SamplerCardViewModel : LoadableViewModelBase, IParametersLo
         }
 
         // Use KSampler if no refiner, otherwise need KSamplerAdvanced
-        if (e.Builder.Connections.RefinerModel is null)
+        if (e.Builder.Connections.Refiner.Model is null)
         {
+            var baseConditioning = e.Builder.Connections.Base.Conditioning.Unwrap();
+
             // No refiner
             var sampler = e.Nodes.AddTypedNode(
                 new ComfyNodeBuilder.KSampler
                 {
                     Name = "Sampler",
-                    Model = e.Builder.Connections.BaseModel ?? throw new ArgumentException("No BaseModel"),
+                    Model = e.Builder.Connections.Base.Model.Unwrap(),
                     Seed = e.Builder.Connections.Seed,
-                    SamplerName = e.Builder.Connections.PrimarySampler?.Name!,
-                    Scheduler = e.Builder.Connections.PrimaryScheduler?.Name!,
+                    SamplerName = primarySampler.Name,
+                    Scheduler = primaryScheduler.Name,
                     Steps = Steps,
                     Cfg = CfgScale,
-                    Positive = e.Temp.Conditioning?.Positive!,
-                    Negative = e.Temp.Conditioning?.Negative!,
+                    Positive = baseConditioning.Positive,
+                    Negative = baseConditioning.Negative,
                     LatentImage = primaryLatent,
                     Denoise = DenoiseStrength,
                 }
@@ -223,20 +222,23 @@ public partial class SamplerCardViewModel : LoadableViewModelBase, IParametersLo
         }
         else
         {
+            var baseConditioning = e.Builder.Connections.Base.Conditioning.Unwrap();
+            var refinerConditioning = e.Builder.Connections.Refiner.Conditioning.Unwrap();
+
             // Advanced base sampler for refiner
             var sampler = e.Nodes.AddTypedNode(
                 new ComfyNodeBuilder.KSamplerAdvanced
                 {
                     Name = "Sampler",
-                    Model = e.Builder.Connections.BaseModel ?? throw new ArgumentException("No BaseModel"),
+                    Model = e.Builder.Connections.Base.Model.Unwrap(),
                     AddNoise = true,
                     NoiseSeed = e.Builder.Connections.Seed,
                     Steps = TotalSteps,
                     Cfg = CfgScale,
-                    SamplerName = e.Builder.Connections.PrimarySampler?.Name!,
-                    Scheduler = e.Builder.Connections.PrimaryScheduler?.Name!,
-                    Positive = e.Temp.Conditioning?.Positive!,
-                    Negative = e.Temp.Conditioning?.Negative!,
+                    SamplerName = primarySampler.Name,
+                    Scheduler = primaryScheduler.Name,
+                    Positive = baseConditioning.Positive,
+                    Negative = baseConditioning.Negative,
                     LatentImage = primaryLatent,
                     StartAtStep = 0,
                     EndAtStep = Steps,
@@ -248,16 +250,16 @@ public partial class SamplerCardViewModel : LoadableViewModelBase, IParametersLo
             var refinerSampler = e.Nodes.AddTypedNode(
                 new ComfyNodeBuilder.KSamplerAdvanced
                 {
-                    Name = "Refiner_Sampler",
-                    Model = e.Builder.Connections.RefinerModel ?? throw new ArgumentException("No RefinerModel"),
+                    Name = "Sampler_Refiner",
+                    Model = e.Builder.Connections.Refiner.Model,
                     AddNoise = false,
                     NoiseSeed = e.Builder.Connections.Seed,
                     Steps = TotalSteps,
                     Cfg = CfgScale,
-                    SamplerName = e.Builder.Connections.PrimarySampler?.Name!,
-                    Scheduler = e.Builder.Connections.PrimaryScheduler?.Name!,
-                    Positive = e.Temp.RefinerConditioning?.Positive!,
-                    Negative = e.Temp.RefinerConditioning?.Negative!,
+                    SamplerName = primarySampler.Name,
+                    Scheduler = primaryScheduler.Name,
+                    Positive = refinerConditioning.Positive,
+                    Negative = refinerConditioning.Negative,
                     // Connect to previous sampler
                     LatentImage = sampler.Output,
                     StartAtStep = Steps,

StabilityMatrix.Avalonia/ViewModels/Inference/Video/ImgToVidModelCardViewModel.cs

@@ -0,0 +1,35 @@
+using System.ComponentModel.DataAnnotations;
+using StabilityMatrix.Avalonia.Controls;
+using StabilityMatrix.Avalonia.Models.Inference;
+using StabilityMatrix.Avalonia.Services;
+using StabilityMatrix.Core.Attributes;
+using StabilityMatrix.Core.Models.Api.Comfy.Nodes;
+
+namespace StabilityMatrix.Avalonia.ViewModels.Inference.Video;
+
+[View(typeof(ModelCard))]
+[ManagedService]
+[Transient]
+public class ImgToVidModelCardViewModel : ModelCardViewModel
+{
+    public ImgToVidModelCardViewModel(IInferenceClientManager clientManager)
+        : base(clientManager)
+    {
+        DisableSettings = true;
+    }
+
+    public override void ApplyStep(ModuleApplyStepEventArgs e)
+    {
+        var imgToVidLoader = e.Nodes.AddTypedNode(
+            new ComfyNodeBuilder.ImageOnlyCheckpointLoader
+            {
+                Name = "ImageOnlyCheckpointLoader",
+                CkptName = SelectedModel?.RelativePath ?? throw new ValidationException("Model not selected")
+            }
+        );
+
+        e.Builder.Connections.Base.Model = imgToVidLoader.Output1;
+        e.Builder.Connections.BaseClipVision = imgToVidLoader.Output2;
+        e.Builder.Connections.Base.VAE = imgToVidLoader.Output3;
+    }
+}

StabilityMatrix.Avalonia/ViewModels/Inference/Video/SvdImgToVidConditioningViewModel.cs

@@ -0,0 +1,104 @@
+using System.ComponentModel.DataAnnotations;
+using CommunityToolkit.Mvvm.ComponentModel;
+using StabilityMatrix.Avalonia.Controls;
+using StabilityMatrix.Avalonia.Models;
+using StabilityMatrix.Avalonia.Models.Inference;
+using StabilityMatrix.Avalonia.ViewModels.Base;
+using StabilityMatrix.Core.Attributes;
+using StabilityMatrix.Core.Models;
+using StabilityMatrix.Core.Models.Api.Comfy.Nodes;
+using StabilityMatrix.Core.Models.Api.Comfy.NodeTypes;
+
+namespace StabilityMatrix.Avalonia.ViewModels.Inference.Video;
+
+[View(typeof(VideoGenerationSettingsCard))]
+[ManagedService]
+[Transient]
+public partial class SvdImgToVidConditioningViewModel
+    : LoadableViewModelBase,
+        IParametersLoadableState,
+        IComfyStep
+{
+    [ObservableProperty]
+    private int width = 1024;
+
+    [ObservableProperty]
+    private int height = 576;
+
+    [ObservableProperty]
+    private int numFrames = 14;
+
+    [ObservableProperty]
+    private int motionBucketId = 127;
+
+    [ObservableProperty]
+    private int fps = 6;
+
+    [ObservableProperty]
+    private double augmentationLevel;
+
+    [ObservableProperty]
+    private double minCfg = 1.0d;
+
+    public void LoadStateFromParameters(GenerationParameters parameters)
+    {
+        Width = parameters.Width;
+        Height = parameters.Height;
+        NumFrames = parameters.FrameCount;
+        MotionBucketId = parameters.MotionBucketId;
+        Fps = parameters.Fps;
+        AugmentationLevel = parameters.AugmentationLevel;
+        MinCfg = parameters.MinCfg;
+    }
+
+    public GenerationParameters SaveStateToParameters(GenerationParameters parameters)
+    {
+        return parameters with
+        {
+            FrameCount = NumFrames,
+            MotionBucketId = MotionBucketId,
+            Fps = Fps,
+            AugmentationLevel = AugmentationLevel,
+            MinCfg = MinCfg,
+        };
+    }
+
+    public void ApplyStep(ModuleApplyStepEventArgs e)
+    {
+        // do VideoLinearCFGGuidance stuff first
+        var cfgGuidanceNode = e.Nodes.AddTypedNode(
+            new ComfyNodeBuilder.VideoLinearCFGGuidance
+            {
+                Name = e.Nodes.GetUniqueName("LinearCfgGuidance"),
+                Model =
+                    e.Builder.Connections.Base.Model ?? throw new ValidationException("Model not selected"),
+                MinCfg = MinCfg
+            }
+        );
+
+        e.Builder.Connections.Base.Model = cfgGuidanceNode.Output;
+
+        // then do the SVD stuff
+        var svdImgToVidConditioningNode = e.Nodes.AddTypedNode(
+            new ComfyNodeBuilder.SVD_img2vid_Conditioning
+            {
+                ClipVision = e.Builder.Connections.BaseClipVision!,
+                InitImage = e.Builder.GetPrimaryAsImage(),
+                Vae = e.Builder.Connections.Base.VAE!,
+                Name = e.Nodes.GetUniqueName("SvdImgToVidConditioning"),
+                Width = Width,
+                Height = Height,
+                VideoFrames = NumFrames,
+                MotionBucketId = MotionBucketId,
+                Fps = Fps,
+                AugmentationLevel = AugmentationLevel
+            }
+        );
+
+        e.Builder.Connections.Base.Conditioning = new ConditioningConnections(
+            svdImgToVidConditioningNode.Output1,
+            svdImgToVidConditioningNode.Output2
+        );
+        e.Builder.Connections.Primary = svdImgToVidConditioningNode.Output3;
+    }
+}

StabilityMatrix.Avalonia/ViewModels/Inference/Video/VideoOutputSettingsCardViewModel.cs

@@ -0,0 +1,94 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using CommunityToolkit.Mvvm.ComponentModel;
+using StabilityMatrix.Avalonia.Controls;
+using StabilityMatrix.Avalonia.Models;
+using StabilityMatrix.Avalonia.Models.Inference;
+using StabilityMatrix.Avalonia.ViewModels.Base;
+using StabilityMatrix.Core.Attributes;
+using StabilityMatrix.Core.Models;
+using StabilityMatrix.Core.Models.Api.Comfy.Nodes;
+
+namespace StabilityMatrix.Avalonia.ViewModels.Inference.Video;
+
+[View(typeof(VideoOutputSettingsCard))]
+[ManagedService]
+[Transient]
+public partial class VideoOutputSettingsCardViewModel
+    : LoadableViewModelBase,
+        IParametersLoadableState,
+        IComfyStep
+{
+    [ObservableProperty]
+    private double fps = 6;
+
+    [ObservableProperty]
+    private bool lossless = true;
+
+    [ObservableProperty]
+    private int quality = 85;
+
+    [ObservableProperty]
+    private VideoOutputMethod selectedMethod = VideoOutputMethod.Default;
+
+    [ObservableProperty]
+    private List<VideoOutputMethod> availableMethods = Enum.GetValues<VideoOutputMethod>().ToList();
+
+    public void LoadStateFromParameters(GenerationParameters parameters)
+    {
+        Fps = parameters.OutputFps;
+        Lossless = parameters.Lossless;
+        Quality = parameters.VideoQuality;
+
+        if (string.IsNullOrWhiteSpace(parameters.VideoOutputMethod))
+            return;
+
+        SelectedMethod = Enum.TryParse<VideoOutputMethod>(parameters.VideoOutputMethod, true, out var method)
+            ? method
+            : VideoOutputMethod.Default;
+    }
+
+    public GenerationParameters SaveStateToParameters(GenerationParameters parameters)
+    {
+        return parameters with
+        {
+            OutputFps = Fps,
+            Lossless = Lossless,
+            VideoQuality = Quality,
+            VideoOutputMethod = SelectedMethod.ToString(),
+        };
+    }
+
+    public void ApplyStep(ModuleApplyStepEventArgs e)
+    {
+        if (e.Builder.Connections.Primary is null)
+            throw new ArgumentException("No Primary");
+
+        var image = e.Builder.Connections.Primary.Match(
+            _ =>
+                e.Builder.GetPrimaryAsImage(
+                    e.Builder.Connections.PrimaryVAE
+                        ?? e.Builder.Connections.Refiner.VAE
+                        ?? e.Builder.Connections.Base.VAE
+                        ?? throw new ArgumentException("No Primary, Refiner, or Base VAE")
+                ),
+            image => image
+        );
+
+        var outputStep = e.Nodes.AddTypedNode(
+            new ComfyNodeBuilder.SaveAnimatedWEBP
+            {
+                Name = e.Nodes.GetUniqueName("SaveAnimatedWEBP"),
+                Images = image,
+                FilenamePrefix = "InferenceVideo",
+                Fps = Fps,
+                Lossless = Lossless,
+                Quality = Quality,
+                Method = SelectedMethod.ToString().ToLowerInvariant()
+            }
+        );
+
+        e.Builder.Connections.OutputNodes.Add(outputStep);
+    }
+}

StabilityMatrix.Avalonia/ViewModels/InferenceViewModel.cs

@@ -53,7 +53,8 @@ public partial class InferenceViewModel : PageViewModelBase, IAsyncDisposable
     private readonly ILiteDbContext liteDbContext;
 
     public override string Title => "Inference";
-    public override IconSource IconSource => new SymbolIconSource { Symbol = Symbol.AppGeneric, IsFilled = true };
+    public override IconSource IconSource =>
+        new SymbolIconSource { Symbol = Symbol.AppGeneric, IsFilled = true };
 
     public RefreshBadgeViewModel ConnectionBadge { get; } =
         new()
@@ -110,6 +111,8 @@ public partial class InferenceViewModel : PageViewModelBase, IAsyncDisposable
         // "Send to Inference"
         EventManager.Instance.InferenceTextToImageRequested += OnInferenceTextToImageRequested;
         EventManager.Instance.InferenceUpscaleRequested += OnInferenceUpscaleRequested;
+        EventManager.Instance.InferenceImageToImageRequested += OnInferenceImageToImageRequested;
+        EventManager.Instance.InferenceImageToVideoRequested += OnInferenceImageToVideoRequested;
 
         MenuSaveAsCommand.WithConditionalNotificationErrorHandler(notificationService);
         MenuOpenProjectCommand.WithConditionalNotificationErrorHandler(notificationService);
@@ -126,9 +129,7 @@ public partial class InferenceViewModel : PageViewModelBase, IAsyncDisposable
 
         IDisposable? onStartupComplete = null;
 
-        Dispatcher
-            .UIThread
-            .Post(() =>
+        Dispatcher.UIThread.Post(() =>
         {
             if (e.CurrentPackagePair?.BasePackage is ComfyUI package)
             {
@@ -138,9 +139,7 @@ public partial class InferenceViewModel : PageViewModelBase, IAsyncDisposable
                     .Take(1)
                     .Subscribe(_ =>
                     {
-                            Dispatcher
-                                .UIThread
-                                .Post(() =>
+                        Dispatcher.UIThread.Post(() =>
                         {
                             if (ConnectCommand.CanExecute(null))
                             {
@@ -216,9 +215,14 @@ public partial class InferenceViewModel : PageViewModelBase, IAsyncDisposable
                     );
 
                     // Set not open
-                    await liteDbContext
-                        .InferenceProjects
-                        .UpdateAsync(project with { IsOpen = false, IsSelected = false, CurrentTabIndex = -1 });
+                    await liteDbContext.InferenceProjects.UpdateAsync(
+                        project with
+                        {
+                            IsOpen = false,
+                            IsSelected = false,
+                            CurrentTabIndex = -1
+                        }
+                    );
                 }
             }
         }
@@ -249,6 +253,16 @@ public partial class InferenceViewModel : PageViewModelBase, IAsyncDisposable
         Dispatcher.UIThread.Post(() => AddUpscalerTabFromImage(e).SafeFireAndForget());
     }
 
+    private void OnInferenceImageToImageRequested(object? sender, LocalImageFile e)
+    {
+        Dispatcher.UIThread.Post(() => AddImageToImageFromImage(e).SafeFireAndForget());
+    }
+
+    private void OnInferenceImageToVideoRequested(object? sender, LocalImageFile e)
+    {
+        Dispatcher.UIThread.Post(() => AddImageToVideoFromImage(e).SafeFireAndForget());
+    }
+
     /// <summary>
     /// Update the database with current tabs
     /// </summary>
@@ -272,7 +286,11 @@ public partial class InferenceViewModel : PageViewModelBase, IAsyncDisposable
             entry.IsOpen = tab == SelectedTab;
             entry.CurrentTabIndex = i;
 
-            Logger.Trace("SyncTabStatesWithDatabase updated entry for tab '{Title}': {@Entry}", tab.TabTitle, entry);
+            Logger.Trace(
+                "SyncTabStatesWithDatabase updated entry for tab '{Title}': {@Entry}",
+                tab.TabTitle,
+                entry
+            );
             await liteDbContext.InferenceProjects.UpsertAsync(entry);
         }
     }
@@ -287,7 +305,9 @@ public partial class InferenceViewModel : PageViewModelBase, IAsyncDisposable
             return;
         }
 
-        var entry = await liteDbContext.InferenceProjects.FindOneAsync(p => p.FilePath == projectFile.ToString());
+        var entry = await liteDbContext.InferenceProjects.FindOneAsync(
+            p => p.FilePath == projectFile.ToString()
+        );
 
         // Create if not found
         entry ??= new InferenceProjectEntry { Id = Guid.NewGuid(), FilePath = projectFile.ToString() };
@@ -295,7 +315,11 @@ public partial class InferenceViewModel : PageViewModelBase, IAsyncDisposable
         entry.IsOpen = tab == SelectedTab;
         entry.CurrentTabIndex = Tabs.IndexOf(tab);
 
-        Logger.Trace("SyncTabStatesWithDatabase updated entry for tab '{Title}': {@Entry}", tab.TabTitle, entry);
+        Logger.Trace(
+            "SyncTabStatesWithDatabase updated entry for tab '{Title}': {@Entry}",
+            tab.TabTitle,
+            entry
+        );
         await liteDbContext.InferenceProjects.UpsertAsync(entry);
     }
 
@@ -408,7 +432,10 @@ public partial class InferenceViewModel : PageViewModelBase, IAsyncDisposable
             return;
         }
 
-        await notificationService.TryAsync(ClientManager.CloseAsync(), "Could not disconnect from ComfyUI backend");
+        await notificationService.TryAsync(
+            ClientManager.CloseAsync(),
+            "Could not disconnect from ComfyUI backend"
+        );
     }
 
     /// <summary>
@@ -464,7 +491,11 @@ public partial class InferenceViewModel : PageViewModelBase, IAsyncDisposable
             await using var stream = await result.OpenWriteAsync();
             stream.SetLength(0); // Overwrite fully
 
-            await JsonSerializer.SerializeAsync(stream, document, new JsonSerializerOptions { WriteIndented = true });
+            await JsonSerializer.SerializeAsync(
+                stream,
+                document,
+                new JsonSerializerOptions { WriteIndented = true }
+            );
         }
         catch (Exception e)
         {
@@ -512,7 +543,11 @@ public partial class InferenceViewModel : PageViewModelBase, IAsyncDisposable
             await using var stream = projectFile.Info.OpenWrite();
             stream.SetLength(0); // Overwrite fully
 
-            await JsonSerializer.SerializeAsync(stream, document, new JsonSerializerOptions { WriteIndented = true });
+            await JsonSerializer.SerializeAsync(
+                stream,
+                document,
+                new JsonSerializerOptions { WriteIndented = true }
+            );
         }
         catch (Exception e)
         {
@@ -624,6 +659,46 @@ public partial class InferenceViewModel : PageViewModelBase, IAsyncDisposable
         await SyncTabStatesWithDatabase();
     }
 
+    private async Task AddImageToImageFromImage(LocalImageFile imageFile)
+    {
+        var imgToImgVm = vmFactory.Get<InferenceImageToImageViewModel>();
+
+        if (!imageFile.FileName.EndsWith("webp"))
+        {
+            imgToImgVm.SelectImageCardViewModel.ImageSource = new ImageSource(imageFile.AbsolutePath);
+        }
+
+        if (imageFile.GenerationParameters != null)
+        {
+            imgToImgVm.LoadStateFromParameters(imageFile.GenerationParameters);
+        }
+
+        Tabs.Add(imgToImgVm);
+        SelectedTab = imgToImgVm;
+
+        await SyncTabStatesWithDatabase();
+    }
+
+    private async Task AddImageToVideoFromImage(LocalImageFile imageFile)
+    {
+        var imgToVidVm = vmFactory.Get<InferenceImageToVideoViewModel>();
+
+        if (imageFile.GenerationParameters != null && imageFile.FileName.EndsWith("webp"))
+        {
+            imgToVidVm.LoadStateFromParameters(imageFile.GenerationParameters);
+        }
+
+        if (!imageFile.FileName.EndsWith("webp"))
+        {
+            imgToVidVm.SelectImageCardViewModel.ImageSource = new ImageSource(imageFile.AbsolutePath);
+        }
+
+        Tabs.Add(imgToVidVm);
+        SelectedTab = imgToVidVm;
+
+        await SyncTabStatesWithDatabase();
+    }
+
     /// <summary>
     /// Menu "Open Project" command.
     /// </summary>

StabilityMatrix.Avalonia/ViewModels/MainWindowViewModel.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
+using System.Reactive.Linq;
 using System.Threading.Tasks;
 using AsyncAwaitBestPractices;
 using Avalonia.Controls;
@@ -10,6 +11,7 @@ using Avalonia.Controls.Primitives;
 using Avalonia.Threading;
 using CommunityToolkit.Mvvm.ComponentModel;
 using FluentAvalonia.UI.Controls;
+using KGySoft.CoreLibraries;
 using NLog;
 using StabilityMatrix.Avalonia.Controls;
 using StabilityMatrix.Avalonia.Services;
@@ -112,10 +114,7 @@ public partial class MainWindowViewModel : ViewModelBase
         var startupTime = CodeTimer.FormatTime(Program.StartupTimer.Elapsed);
         Logger.Info($"App started ({startupTime})");
 
-        if (
-            Program.Args.DebugOneClickInstall
-            || settingsManager.Settings.InstalledPackages.Count == 0
-        )
+        if (Program.Args.DebugOneClickInstall || settingsManager.Settings.InstalledPackages.Count == 0)
         {
             var viewModel = dialogFactory.Get<OneClickInstallViewModel>();
             var dialog = new BetterContentDialog
@@ -148,8 +147,8 @@ public partial class MainWindowViewModel : ViewModelBase
                 .Where(p => p.GetType().GetCustomAttributes(typeof(PreloadAttribute), true).Any())
         )
         {
-            Dispatcher.UIThread
-                .InvokeAsync(
+            Dispatcher
+                .UIThread.InvokeAsync(
                     async () =>
                     {
                         var stopwatch = Stopwatch.StartNew();

StabilityMatrix.Avalonia/ViewModels/OutputsPageViewModel.cs

@@ -93,6 +93,8 @@ public partial class OutputsPageViewModel : PageViewModelBase
             ? Resources.Label_OneImageSelected
             : string.Format(Resources.Label_NumImagesSelected, NumItemsSelected);
 
+    private string[] allowedExtensions = [".png", ".webp"];
+
     public OutputsPageViewModel(
         ISettingsManager settingsManager,
         IPackageFactory packageFactory,
@@ -313,6 +315,18 @@ public partial class OutputsPageViewModel : PageViewModelBase
         EventManager.Instance.OnInferenceUpscaleRequested(vm.ImageFile);
     }
 
+    public void SendToImageToImage(OutputImageViewModel vm)
+    {
+        navigationService.NavigateTo<InferenceViewModel>();
+        EventManager.Instance.OnInferenceImageToImageRequested(vm.ImageFile);
+    }
+
+    public void SendToImageToVideo(OutputImageViewModel vm)
+    {
+        navigationService.NavigateTo<InferenceViewModel>();
+        EventManager.Instance.OnInferenceImageToVideoRequested(vm.ImageFile);
+    }
+
     public void ClearSelection()
     {
         foreach (var output in Outputs)
@@ -434,11 +448,14 @@ public partial class OutputsPageViewModel : PageViewModelBase
 
             var directory = category.Tag.ToString();
 
-            foreach (var path in Directory.EnumerateFiles(directory, "*.png", SearchOption.AllDirectories))
+            foreach (var path in Directory.EnumerateFiles(directory, "*.*", SearchOption.AllDirectories))
             {
                 try
                 {
                     var file = new FilePath(path);
+                    if (!allowedExtensions.Contains(file.Extension))
+                        continue;
+
                     var newPath = settingsManager.ConsolidatedImagesDirectory + file.Name;
                     if (file.FullPath == newPath)
                         continue;
@@ -496,7 +513,8 @@ public partial class OutputsPageViewModel : PageViewModelBase
         }
 
         var files = Directory
-            .EnumerateFiles(directory, "*.png", SearchOption.AllDirectories)
+            .EnumerateFiles(directory, "*.*", SearchOption.AllDirectories)
+            .Where(path => allowedExtensions.Contains(new FilePath(path).Extension))
             .Select(file => LocalImageFile.FromPath(file))
             .ToList();
 

StabilityMatrix.Avalonia/ViewModels/PackageManager/PackageCardViewModel.cs

@@ -97,7 +97,10 @@ public partial class PackageCardViewModel : ProgressViewModel
         if (string.IsNullOrWhiteSpace(value?.PackageName))
             return;
 
-        if (value.PackageName == UnknownPackage.Key || packageFactory.FindPackageByName(value.PackageName) is null)
+        if (
+            value.PackageName == UnknownPackage.Key
+            || packageFactory.FindPackageByName(value.PackageName) is null
+        )
         {
             IsUnknownPackage = true;
             CardImageSource = "";
@@ -124,7 +127,11 @@ public partial class PackageCardViewModel : ProgressViewModel
         if (Design.IsDesignMode || !settingsManager.IsLibraryDirSet || Package is not { } currentPackage)
             return;
 
-        if (packageFactory.FindPackageByName(currentPackage.PackageName) is { } basePackage and not UnknownPackage)
+        if (
+            packageFactory.FindPackageByName(currentPackage.PackageName)
+            is { } basePackage
+                and not UnknownPackage
+        )
         {
             // Migrate old packages with null preferred shared folder method
             currentPackage.PreferredSharedFolderMethod ??= basePackage.RecommendedSharedFolderMethod;
@@ -185,11 +192,18 @@ public partial class PackageCardViewModel : ProgressViewModel
             var packagePath = new DirectoryPath(settingsManager.LibraryDir, Package.LibraryPath);
             var deleteTask = packagePath.DeleteVerboseAsync(logger);
 
-            var taskResult = await notificationService.TryAsync(deleteTask, Resources.Text_SomeFilesCouldNotBeDeleted);
+            var taskResult = await notificationService.TryAsync(
+                deleteTask,
+                Resources.Text_SomeFilesCouldNotBeDeleted
+            );
             if (taskResult.IsSuccessful)
             {
                 notificationService.Show(
-                    new Notification(Resources.Label_PackageUninstalled, Package.DisplayName, NotificationType.Success)
+                    new Notification(
+                        Resources.Label_PackageUninstalled,
+                        Package.DisplayName,
+                        NotificationType.Success
+                    )
                 );
 
                 if (!IsUnknownPackage)
@@ -254,7 +268,12 @@ public partial class PackageCardViewModel : ProgressViewModel
                 versionOptions.CommitHash = latest.Sha;
             }
 
-            var updatePackageStep = new UpdatePackageStep(settingsManager, Package, versionOptions, basePackage);
+            var updatePackageStep = new UpdatePackageStep(
+                settingsManager,
+                Package,
+                versionOptions,
+                basePackage
+            );
             var steps = new List<IPackageStep> { updatePackageStep };
 
             EventManager.Instance.OnPackageInstallProgressAdded(runner);
@@ -381,7 +400,8 @@ public partial class PackageCardViewModel : ProgressViewModel
         if (basePackage == null)
             return false;
 
-        var canCheckUpdate = Package.LastUpdateCheck == null || Package.LastUpdateCheck < DateTime.Now.AddMinutes(-15);
+        var canCheckUpdate =
+            Package.LastUpdateCheck == null || Package.LastUpdateCheck < DateTime.Now.AddMinutes(-15);
 
         if (!canCheckUpdate)
         {

StabilityMatrix.Avalonia/ViewModels/Settings/MainSettingsViewModel.cs

@@ -24,7 +24,9 @@ using Avalonia.Threading;
 using CommunityToolkit.Mvvm.ComponentModel;
 using CommunityToolkit.Mvvm.Input;
 using DynamicData.Binding;
+using ExifLibrary;
 using FluentAvalonia.UI.Controls;
+using MetadataExtractor.Formats.Exif;
 using NLog;
 using SkiaSharp;
 using StabilityMatrix.Avalonia.Animations;
@@ -75,7 +77,8 @@ public partial class MainSettingsViewModel : PageViewModelBase
     public SharedState SharedState { get; }
 
     public override string Title => "Settings";
-    public override IconSource IconSource => new SymbolIconSource { Symbol = Symbol.Settings, IsFilled = true };
+    public override IconSource IconSource =>
+        new SymbolIconSource { Symbol = Symbol.Settings, IsFilled = true };
 
     // ReSharper disable once MemberCanBeMadeStatic.Global
     public string AppVersion =>
@@ -132,7 +135,8 @@ public partial class MainSettingsViewModel : PageViewModelBase
     [ObservableProperty]
     private MemoryInfo memoryInfo;
 
-    private readonly DispatcherTimer hardwareInfoUpdateTimer = new() { Interval = TimeSpan.FromSeconds(2.627) };
+    private readonly DispatcherTimer hardwareInfoUpdateTimer =
+        new() { Interval = TimeSpan.FromSeconds(2.627) };
 
     public Task<CpuInfo> CpuInfoAsync => HardwareHelper.GetCpuInfoAsync();
 
@@ -198,8 +202,16 @@ public partial class MainSettingsViewModel : PageViewModelBase
             true
         );
 
-        settingsManager.RelayPropertyFor(this, vm => vm.SelectedAnimationScale, settings => settings.AnimationScale);
-        settingsManager.RelayPropertyFor(this, vm => vm.HolidayModeSetting, settings => settings.HolidayModeSetting);
+        settingsManager.RelayPropertyFor(
+            this,
+            vm => vm.SelectedAnimationScale,
+            settings => settings.AnimationScale
+        );
+        settingsManager.RelayPropertyFor(
+            this,
+            vm => vm.HolidayModeSetting,
+            settings => settings.HolidayModeSetting
+        );
 
         DebugThrowAsyncExceptionCommand.WithNotificationErrorHandler(notificationService, LogLevel.Warn);
 
@@ -277,9 +289,7 @@ public partial class MainSettingsViewModel : PageViewModelBase
                 CloseButtonText = Resources.Action_RelaunchLater
             };
 
-            Dispatcher
-                .UIThread
-                .InvokeAsync(async () =>
+            Dispatcher.UIThread.InvokeAsync(async () =>
             {
                 if (await dialog.ShowAsync() == ContentDialogResult.Primary)
                 {
@@ -313,9 +323,7 @@ public partial class MainSettingsViewModel : PageViewModelBase
     [RelayCommand]
     private void NavigateToSubPage(Type viewModelType)
     {
-        Dispatcher
-            .UIThread
-            .Post(
+        Dispatcher.UIThread.Post(
             () =>
                 settingsNavigationService.NavigateTo(
                     viewModelType,
@@ -350,8 +358,7 @@ public partial class MainSettingsViewModel : PageViewModelBase
         {
             // Save settings
             var newEnvVars = viewModel
-                .EnvVars
-                .Where(kvp => !string.IsNullOrWhiteSpace(kvp.Key))
+                .EnvVars.Where(kvp => !string.IsNullOrWhiteSpace(kvp.Key))
                 .GroupBy(kvp => kvp.Key, StringComparer.Ordinal)
                 .ToDictionary(g => g.Key, g => g.First().Value, StringComparer.Ordinal);
             settingsManager.Transaction(s => s.EnvironmentVariables = newEnvVars);
@@ -405,7 +412,10 @@ public partial class MainSettingsViewModel : PageViewModelBase
 
         await using var _ = new MinimumDelay(200, 300);
 
-        var shortcutDir = new DirectoryPath(Environment.GetFolderPath(Environment.SpecialFolder.StartMenu), "Programs");
+        var shortcutDir = new DirectoryPath(
+            Environment.GetFolderPath(Environment.SpecialFolder.StartMenu),
+            "Programs"
+        );
         var shortcutLink = shortcutDir.JoinFile("Stability Matrix.lnk");
 
         var appPath = Compat.AppCurrentPath;

StabilityMatrix.Avalonia/Views/Dialogs/ImageViewerDialog.axaml

@@ -10,6 +10,9 @@
     xmlns:mocks="clr-namespace:StabilityMatrix.Avalonia.DesignData"
     xmlns:ui="clr-namespace:FluentAvalonia.UI.Controls;assembly=FluentAvalonia"
     xmlns:vmDialogs="clr-namespace:StabilityMatrix.Avalonia.ViewModels.Dialogs"
+    xmlns:models="clr-namespace:StabilityMatrix.Avalonia.Models"
+    xmlns:gif="clr-namespace:Avalonia.Gif;assembly=Avalonia.Gif"
+    xmlns:input="clr-namespace:FluentAvalonia.UI.Input;assembly=FluentAvalonia"
     HorizontalContentAlignment="Stretch"
     VerticalContentAlignment="Stretch"
     d:DataContext="{x:Static mocks:DesignData.ImageViewerViewModel}"
@@ -46,24 +49,46 @@
         HorizontalAlignment="Stretch"
         VerticalAlignment="Stretch"
         RowDefinitions="*,Auto">
+        <Grid.Resources>
+            <input:StandardUICommand 
+                x:Key="CopyImageCommand" 
+                Command="{Binding CopyImageCommand}"/>
+        </Grid.Resources>
 
+        <ContentPresenter Grid.Row="0"
+                          DataContext="{Binding ImageSource}" 
+                          Content="{Binding }">
+            <ContentPresenter.ContentTemplate>
+                <controls:DataTemplateSelector x:TypeArguments="models:ImageSourceTemplateType">
+                    <DataTemplate x:Key="{x:Static models:ImageSourceTemplateType.WebpAnimation}" DataType="models:ImageSource">
+                        <gif:GifImage
+                            Stretch="Uniform"
+                            SourceUri="{Binding LocalFile.FullPath}"/>
+                    </DataTemplate>
+                    
+                    <DataTemplate x:Key="{x:Static models:ImageSourceTemplateType.Image}" DataType="models:ImageSource">
                         <controls:AdvancedImageBox
                             Name="ImageBox"
-            Image="{Binding ImageSource.BitmapAsync^}" 
+                            CornerRadius="4"
+                            Image="{Binding BitmapAsync^}"
                             SizeMode="Fit">
                             <controls:AdvancedImageBox.ContextFlyout>
                                 <ui:FAMenuFlyout>
                                     <ui:MenuFlyoutItem
                                         x:Name="CopyMenuItem"
-                        IsEnabled="{OnPlatform Windows=True, Default=False}"
-                        Command="{Binding CopyImageCommand}"
-                        CommandParameter="{Binding #ImageBox.Image}"
-                        Text="Copy"
+                                        Command="{StaticResource CopyImageCommand}"
+                                        CommandParameter="{Binding $parent[controls:AdvancedImageBox].Image}"
                                         HotKey="Ctrl+C"
-                        IconSource="Copy" />
+                                        IconSource="Copy"
+                                        IsEnabled="{OnPlatform Windows=True, Default=False}"
+                                        Text="Copy" />
                                 </ui:FAMenuFlyout>
                             </controls:AdvancedImageBox.ContextFlyout>
                         </controls:AdvancedImageBox>
+                    </DataTemplate>
+                </controls:DataTemplateSelector>
+            </ContentPresenter.ContentTemplate>
+        </ContentPresenter>
 
         <!--  Info button  -->
         <Grid

StabilityMatrix.Avalonia/Views/Inference/InferenceImageToVideoView.axaml

@@ -0,0 +1,222 @@
+<dock:DockUserControlBase
+    x:Class="StabilityMatrix.Avalonia.Views.Inference.InferenceImageToVideoView"
+    xmlns="https://github.com/avaloniaui"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:controls="clr-namespace:StabilityMatrix.Avalonia.Controls"
+    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+    xmlns:icons="clr-namespace:Projektanker.Icons.Avalonia;assembly=Projektanker.Icons.Avalonia"
+    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+    xmlns:mocks="clr-namespace:StabilityMatrix.Avalonia.DesignData"
+    xmlns:vmInference="using:StabilityMatrix.Avalonia.ViewModels.Inference"
+    xmlns:dock="clr-namespace:StabilityMatrix.Avalonia.Controls.Dock"
+    xmlns:modelsInference="clr-namespace:StabilityMatrix.Avalonia.Models.Inference"
+    xmlns:gif="clr-namespace:Avalonia.Gif;assembly=Avalonia.Gif"
+    d:DataContext="{x:Static mocks:DesignData.InferenceImageToVideoViewModel}"
+    d:DesignHeight="800"
+    d:DesignWidth="1000"
+    x:DataType="vmInference:InferenceImageToVideoViewModel"
+    Focusable="True"
+    mc:Ignorable="d">
+
+    <Grid Margin="2,0,2,8">
+        <DockControl
+            x:Name="Dock"
+            InitializeFactory="True"
+            InitializeLayout="True">
+            <DockControl.Factory>
+                <Factory />
+            </DockControl.Factory>
+
+            <RootDock
+                x:Name="Root"
+                DefaultDockable="{Binding #MainLayout}"
+                Id="Root"
+                IsCollapsable="False">
+
+                <ProportionalDock
+                    x:Name="MainLayout"
+                    Id="MainLayout"
+                    Orientation="Horizontal">
+                    <!--  Left Pane  -->
+                    <ProportionalDock
+                        Proportion="0.3"
+                        Orientation="Vertical">
+                        <ToolDock
+                            x:Name="SelectImagePane"
+                            Alignment="Left"
+                            Id="ConfigPane"
+                            Proportion="0.3">
+                            <Tool
+                                x:Name="SelectImageTool"
+                                Title="Image Input"
+                                x:DataType="Tool"
+                                Id="ConfigTool"
+                                CanClose="False">
+                                <controls:SelectImageCard 
+                                    DataContext="{Binding #Dock.((vmInference:InferenceImageToVideoViewModel)DataContext).SelectImageCardViewModel}" />
+                            </Tool>
+                        </ToolDock>
+                        <ToolDock
+                            x:Name="ConfigPane"
+                            Alignment="Left"
+                            Id="ConfigPane"
+                            Proportion="0.6">
+                            <Tool
+                                x:Name="ConfigTool"
+                                Title="Config"
+                                x:DataType="Tool"
+                                Id="ConfigTool"
+                                CanClose="False">
+                                <controls:StackCard
+                                    Opacity="1"
+                                    DataContext="{ReflectionBinding ElementName=Dock, Path=DataContext.StackCardViewModel}" />
+                            </Tool>
+                        </ToolDock>
+                    </ProportionalDock>
+                    <ProportionalDockSplitter x:Name="Splitter1" Id="Splitter1" />
+
+                    <!--  Middle Pane  -->
+                    <ProportionalDock
+                        Proportion="0.5"
+                        Orientation="Vertical">
+                        <ToolDock
+                            x:Name="ImageGalleryPane"
+                            Alignment="Right"
+                            Id="ImageGalleryPane"
+                            Proportion="0.9">
+                            <Tool
+                                x:Name="ImageGalleryTool"
+                                Title="Image Output"
+                                x:DataType="Tool"
+                                Id="ImageGalleryTool"
+                                CanClose="False">
+
+                                <Grid
+                                    x:CompileBindings="False"
+                                    DataContext="{Binding ElementName=Dock, Path=DataContext}">
+                                    <controls:ImageGalleryCard
+                                        Grid.Row="0"
+                                        DataContext="{Binding ImageGalleryCardViewModel}"/>
+                                    
+                                    <StackPanel
+                                        DataContext="{Binding OutputProgress}"
+                                        Margin="2,1,2,4"
+                                        Spacing="4"
+                                        VerticalAlignment="Top">
+                                        <ProgressBar
+                                            IsVisible="{Binding IsProgressVisible}"
+                                            IsIndeterminate="{Binding IsIndeterminate}"
+                                            Maximum="{Binding Maximum}"
+                                            Value="{Binding Value}" />
+
+                                        <TextBlock
+                                            Margin="0,10,0,0"
+                                            IsVisible="{Binding IsTextVisible}"
+                                            TextAlignment="Center"
+                                            Text="{Binding Text}" />
+                                    </StackPanel>
+                                </Grid>
+                            </Tool>
+                        </ToolDock>
+                        <ToolDock x:Name="GeneratePane"
+                                  Alignment="Top"
+                                  Id="ConfigPane"
+                                  Proportion="0.1">
+                            <Tool
+                                x:Name="GenerateTool"
+                                Title="Generate"
+                                x:DataType="Tool"
+                                Id="GenerateTool"
+                                CanClose="False">
+                                <!--  Generate Buttons  -->
+                                <StackPanel Margin="0,6,0,0"
+                                            x:CompileBindings="False"
+                                            DataContext="{Binding ElementName=Dock, Path=DataContext}">
+                                    <controls:Card Padding="8">
+                                        <Grid
+                                            HorizontalAlignment="Center"
+                                            ColumnDefinitions="Auto,*,Auto"
+                                            RowDefinitions="Auto,*">
+                                            <Grid.Styles>
+                                                <Style Selector="Button">
+                                                    <Setter Property="MinHeight" Value="32" />
+                                                </Style>
+                                            </Grid.Styles>
+
+                                            <!--  Main Generate Button  -->
+                                            <Button
+                                                x:Name="GenerateButton"
+                                                Grid.Row="1"
+                                                Grid.Column="1"
+                                                Width="130"
+                                                HorizontalAlignment="Stretch"
+                                                Classes="accent"
+                                                Command="{Binding GenerateImageCommand}"
+                                                CommandParameter="{x:Static modelsInference:GenerateFlags.None}"
+                                                IsVisible="{Binding !GenerateImageCommand.CanBeCanceled}">
+                                                <Panel>
+                                                    <TextBlock IsVisible="{Binding #GenerateButton.IsEnabled}"
+                                                               Text="Generate Image" />
+                                                    <controls:ProgressRing IsIndeterminate="True"
+                                                                           IsVisible="{Binding !#GenerateButton.IsEnabled}" />
+                                                </Panel>
+                                            </Button>
+                                            <!--  Cancel Button  -->
+                                            <Button
+                                                x:Name="CancelButton"
+                                                Grid.Row="1"
+                                                Grid.Column="1"
+                                                Width="130"
+                                                HorizontalAlignment="Stretch"
+                                                icons:Attached.Icon="fa-solid fa-stop"
+                                                Command="{Binding GenerateImageCancelCommand}"
+                                                IsVisible="{Binding GenerateImageCommand.CanBeCanceled}" />
+
+                                            <Button
+                                                Grid.Row="1"
+                                                Grid.Column="2"
+                                                Margin="4,0"
+                                                Padding="12,8"
+                                                HorizontalAlignment="Left"
+                                                icons:Attached.Icon="fa-solid fa-repeat"
+                                                Classes="transparent"
+                                                Command="{Binding GenerateImageCommand}"
+                                                CommandParameter="{x:Static modelsInference:GenerateFlags.UseCurrentSeed}"
+                                                ToolTip.Tip="Generate with current seed" />
+                                        </Grid>
+                                    </controls:Card>
+                                </StackPanel>
+                            </Tool>
+                        </ToolDock>
+                    </ProportionalDock>
+
+                    <ProportionalDockSplitter x:Name="Splitter3" Id="Splitter3" />
+
+                    <!--  Right Pane  -->
+                    <ToolDock
+                        x:Name="ImageFolderPane"
+                        Alignment="Right"
+                        Id="ImageFolderPane"
+                        Proportion="0.2">
+                        <Tool
+                            x:Name="ImageFolderTool"
+                            x:DataType="Tool"
+                            Title="Gallery"
+                            Id="ImageFolderTool"
+                            CanClose="False">
+
+                            <Grid
+                                x:CompileBindings="False"
+                                DataContext="{Binding ElementName=Dock, Path=DataContext}">
+                                <controls:ImageFolderCard
+                                    DataContext="{Binding ImageFolderCardViewModel}" />
+                            </Grid>
+                        </Tool>
+                    </ToolDock>
+
+                </ProportionalDock>
+            </RootDock>
+
+        </DockControl>
+    </Grid>
+</dock:DockUserControlBase>

StabilityMatrix.Avalonia/Views/Inference/InferenceImageToVideoView.axaml.cs

@@ -0,0 +1,13 @@
+using StabilityMatrix.Avalonia.Controls.Dock;
+using StabilityMatrix.Core.Attributes;
+
+namespace StabilityMatrix.Avalonia.Views.Inference;
+
+[Transient]
+public partial class InferenceImageToVideoView : DockUserControlBase
+{
+    public InferenceImageToVideoView()
+    {
+        InitializeComponent();
+    }
+}

StabilityMatrix.Avalonia/Views/InferencePage.axaml

@@ -70,6 +70,16 @@
                             Symbol="ResizeImage"/>
                     </ui:CommandBarButton.IconSource>
                 </ui:CommandBarButton>
+                <ui:CommandBarButton
+                    Click="AddTabMenu_ImgToVideo_OnClick"
+                    Label="Image to Video"
+                    ToolTip.Tip="Image to Video">
+                    <ui:CommandBarButton.IconSource>
+                        <fluentIcons:SymbolIconSource
+                            FontSize="10"
+                            Symbol="Video"/>
+                    </ui:CommandBarButton.IconSource>
+                </ui:CommandBarButton>
             </ui:CommandBarFlyout.SecondaryCommands>
         </ui:CommandBarFlyout>
     </controls:UserControlBase.Resources>

StabilityMatrix.Avalonia/Views/InferencePage.axaml.cs

@@ -55,4 +55,9 @@ public partial class InferencePage : UserControlBase
             (DataContext as InferenceViewModel)!.AddTabCommand.Execute(type);
         }
     }
+
+    private void AddTabMenu_ImgToVideo_OnClick(object? sender, RoutedEventArgs e)
+    {
+        (DataContext as InferenceViewModel)!.AddTabCommand.Execute(InferenceProjectType.ImageToVideo);
+    }
 }

StabilityMatrix.Avalonia/Views/MainWindow.axaml.cs

@@ -4,6 +4,9 @@ using System.ComponentModel;
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Linq;
+using System.Reactive;
+using System.Reactive.Linq;
+using System.Threading;
 using AsyncImageLoader;
 using Avalonia;
 using Avalonia.Controls;
@@ -34,8 +37,11 @@ using StabilityMatrix.Avalonia.ViewModels.Base;
 using StabilityMatrix.Core.Attributes;
 using StabilityMatrix.Core.Extensions;
 using StabilityMatrix.Core.Helper;
+using StabilityMatrix.Core.Models.Settings;
 using StabilityMatrix.Core.Models.Update;
 using StabilityMatrix.Core.Processes;
+using StabilityMatrix.Core.Services;
+using TeachingTip = FluentAvalonia.UI.Controls.TeachingTip;
 #if DEBUG
 using StabilityMatrix.Avalonia.Diagnostics.Views;
 #endif
@@ -48,6 +54,7 @@ public partial class MainWindow : AppWindowBase
 {
     private readonly INotificationService notificationService;
     private readonly INavigationService<MainWindowViewModel> navigationService;
+    private readonly ISettingsManager settingsManager;
 
     private FlyoutBase? progressFlyout;
 
@@ -61,11 +68,13 @@ public partial class MainWindow : AppWindowBase
 
     public MainWindow(
         INotificationService notificationService,
-        INavigationService<MainWindowViewModel> navigationService
+        INavigationService<MainWindowViewModel> navigationService,
+        ISettingsManager settingsManager
     )
     {
         this.notificationService = notificationService;
         this.navigationService = navigationService;
+        this.settingsManager = settingsManager;
 
         InitializeComponent();
 
@@ -82,6 +91,47 @@ public partial class MainWindow : AppWindowBase
         EventManager.Instance.ToggleProgressFlyout += (_, _) => progressFlyout?.Hide();
         EventManager.Instance.CultureChanged += (_, _) => SetDefaultFonts();
         EventManager.Instance.UpdateAvailable += OnUpdateAvailable;
+
+        Observable
+            .FromEventPattern<SizeChangedEventArgs>(this, nameof(SizeChanged))
+            .Where(x => x.EventArgs.PreviousSize != x.EventArgs.NewSize)
+            .Throttle(TimeSpan.FromMilliseconds(100))
+            .Select(x => x.EventArgs.NewSize)
+            .ObserveOn(SynchronizationContext.Current)
+            .Subscribe(newSize =>
+            {
+                var validWindowPosition = Screens.All.Any(screen => screen.Bounds.Contains(Position));
+
+                settingsManager.Transaction(
+                    s =>
+                    {
+                        s.WindowSettings = new WindowSettings(
+                            newSize.Width,
+                            newSize.Height,
+                            validWindowPosition ? Position.X : 0,
+                            validWindowPosition ? Position.Y : 0
+                        );
+                    },
+                    ignoreMissingLibraryDir: true
+                );
+            });
+
+        Observable
+            .FromEventPattern<PixelPointEventArgs>(this, nameof(PositionChanged))
+            .Where(x => Screens.All.Any(screen => screen.Bounds.Contains(x.EventArgs.Point)))
+            .Throttle(TimeSpan.FromMilliseconds(100))
+            .Select(x => x.EventArgs.Point)
+            .ObserveOn(SynchronizationContext.Current)
+            .Subscribe(position =>
+            {
+                settingsManager.Transaction(
+                    s =>
+                    {
+                        s.WindowSettings = new WindowSettings(Width, Height, position.X, position.Y);
+                    },
+                    ignoreMissingLibraryDir: true
+                );
+            });
     }
 
     /// <inheritdoc />

StabilityMatrix.Avalonia/Views/OutputsPage.axaml

@@ -219,19 +219,11 @@
                                             IconSource="FullScreenMaximize"
                                             Text="{x:Static lang:Resources.Label_TextToImage}" />
                                         <ui:MenuFlyoutItem
+                                            Command="{Binding $parent[ItemsRepeater].((vm:OutputsPageViewModel)DataContext).SendToImageToImage}"
                                             CommandParameter="{Binding}"
                                             HotKey="{x:Null}"
                                             IconSource="ImageCopy"
-                                            IsEnabled="False"
-                                            IsVisible="False"
                                             Text="{x:Static lang:Resources.Label_ImageToImage}" />
-                                        <ui:MenuFlyoutItem
-                                            CommandParameter="{Binding}"
-                                            HotKey="{x:Null}"
-                                            IconSource="ImageEdit"
-                                            IsEnabled="False"
-                                            IsVisible="False"
-                                            Text="{x:Static lang:Resources.Label_Inpainting}" />
                                         <ui:MenuFlyoutItem
                                             Command="{Binding $parent[ItemsRepeater].((vm:OutputsPageViewModel)DataContext).SendToUpscale}"
                                             CommandParameter="{Binding}"
@@ -241,6 +233,12 @@
                                                 <fluentAvalonia:SymbolIconSource FontSize="10" Symbol="ResizeImage" />
                                             </ui:MenuFlyoutItem.IconSource>
                                         </ui:MenuFlyoutItem>
+                                        <ui:MenuFlyoutItem
+                                            Command="{Binding $parent[ItemsRepeater].((vm:OutputsPageViewModel)DataContext).SendToImageToVideo}"
+                                            CommandParameter="{Binding}"
+                                            HotKey="{x:Null}"
+                                            IconSource="Video"
+                                            Text="{x:Static lang:Resources.Label_ImageToVideo}" />
                                     </ui:MenuFlyoutSubItem>
                                 </ui:FAMenuFlyout>
                             </selectableImageCard:SelectableImageButton.ContextFlyout>

StabilityMatrix.Core/Animation/GifConverter.cs

@@ -0,0 +1,50 @@
+using KGySoft.Drawing.Imaging;
+using KGySoft.Drawing.SkiaSharp;
+using SkiaSharp;
+
+namespace StabilityMatrix.Core.Animation;
+
+public class GifConverter
+{
+    public static IEnumerable<IReadableBitmapData> EnumerateAnimatedWebp(Stream webpSource)
+    {
+        using var webp = new SKManagedStream(webpSource);
+        using var codec = SKCodec.Create(webp);
+
+        var info = new SKImageInfo(codec.Info.Width, codec.Info.Height);
+
+        for (var i = 0; i < codec.FrameCount; i++)
+        {
+            using var tempSurface = new SKBitmap(info);
+
+            codec.GetFrameInfo(i, out var frameInfo);
+
+            var decodeInfo = info.WithAlphaType(frameInfo.AlphaType);
+
+            tempSurface.TryAllocPixels(decodeInfo);
+
+            var result = codec.GetPixels(decodeInfo, tempSurface.GetPixels(), new SKCodecOptions(i));
+
+            if (result != SKCodecResult.Success)
+                throw new InvalidDataException($"Could not decode frame {i} of {codec.FrameCount}.");
+
+            using var peekPixels = tempSurface.PeekPixels();
+
+            yield return peekPixels.GetReadableBitmapData(WorkingColorSpace.Default);
+        }
+    }
+
+    public static Task ConvertAnimatedWebpToGifAsync(Stream webpSource, Stream gifOutput)
+    {
+        var gifBitmaps = EnumerateAnimatedWebp(webpSource);
+
+        return GifEncoder.EncodeAnimationAsync(
+            new AnimatedGifConfiguration(gifBitmaps, TimeSpan.FromMilliseconds(150))
+            {
+                Quantizer = OptimizedPaletteQuantizer.Wu(alphaThreshold: 0),
+                AllowDeltaFrames = true
+            },
+            gifOutput
+        );
+    }
+}

StabilityMatrix.Core/Extensions/NullableExtensions.cs

@@ -0,0 +1,47 @@
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+
+namespace StabilityMatrix.Core.Extensions;
+
+public static class NullableExtensions
+{
+    /// <summary>
+    /// Unwraps a nullable object, throwing an exception if it is null.
+    /// </summary>
+    /// <exception cref="InvalidOperationException">
+    /// Thrown if (<typeparamref name="T"/>) <paramref name="obj"/> is null.
+    /// </exception>
+    [DebuggerStepThrough]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static T Unwrap<T>([NotNull] this T? obj, [CallerArgumentExpression("obj")] string? paramName = null)
+        where T : class
+    {
+        if (obj is null)
+        {
+            throw new ArgumentNullException(paramName, $"Unwrap of a null value ({typeof(T)}) {paramName}.");
+        }
+        return obj;
+    }
+
+    /// <summary>
+    /// Unwraps a nullable struct object, throwing an exception if it is null.
+    /// </summary>
+    /// <exception cref="InvalidOperationException">
+    /// Thrown if (<typeparamref name="T"/>) <paramref name="obj"/> is null.
+    /// </exception>
+    [DebuggerStepThrough]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static T Unwrap<T>([NotNull] this T? obj, [CallerArgumentExpression("obj")] string? paramName = null)
+        where T : struct
+    {
+        if (obj is null)
+        {
+            throw new ArgumentNullException(paramName, $"Unwrap of a null value ({typeof(T)}) {paramName}.");
+        }
+        return obj.Value;
+    }
+}

StabilityMatrix.Core/Helper/ArchiveHelper.cs

@@ -85,12 +85,9 @@ public static partial class ArchiveHelper
 
     public static async Task<ArchiveInfo> Extract7Z(string archivePath, string extractDirectory)
     {
-        var args =
-            $"x {ProcessRunner.Quote(archivePath)} -o{ProcessRunner.Quote(extractDirectory)} -y";
+        var args = $"x {ProcessRunner.Quote(archivePath)} -o{ProcessRunner.Quote(extractDirectory)} -y";
 
-        var result = await ProcessRunner
-            .GetProcessResultAsync(SevenZipPath, args)
-            .ConfigureAwait(false);
+        var result = await ProcessRunner.GetProcessResultAsync(SevenZipPath, args).ConfigureAwait(false);
 
         result.EnsureSuccessExitCode();
 
@@ -130,27 +127,17 @@ public static partial class ArchiveHelper
                 var percent = int.Parse(match.Groups[1].Value);
                 var currentFile = match.Groups[2].Value;
                 progress.Report(
-                    new ProgressReport(
-                        percent / (float)100,
-                        "Extracting",
-                        currentFile,
-                        type: ProgressType.Extract
-                    )
+                    new ProgressReport(percent / (float)100, "Extracting", currentFile, type: ProgressType.Extract)
                 );
             }
         });
         progress.Report(new ProgressReport(-1, isIndeterminate: true, type: ProgressType.Extract));
 
         // Need -bsp1 for progress reports
-        var args =
-            $"x {ProcessRunner.Quote(archivePath)} -o{ProcessRunner.Quote(extractDirectory)} -y -bsp1";
+        var args = $"x {ProcessRunner.Quote(archivePath)} -o{ProcessRunner.Quote(extractDirectory)} -y -bsp1";
         Logger.Debug($"Starting process '{SevenZipPath}' with arguments '{args}'");
 
-        using var process = ProcessRunner.StartProcess(
-            SevenZipPath,
-            args,
-            outputDataReceived: onOutput
-        );
+        using var process = ProcessRunner.StartProcess(SevenZipPath, args, outputDataReceived: onOutput);
         await ProcessRunner.WaitForExitConditionAsync(process).ConfigureAwait(false);
 
         progress.Report(new ProgressReport(1f, "Finished extracting", type: ProgressType.Extract));
@@ -269,11 +256,7 @@ public static partial class ArchiveHelper
             .StartNew(
                 () =>
                 {
-                    var extractOptions = new ExtractionOptions
-                    {
-                        Overwrite = true,
-                        ExtractFullPath = true,
-                    };
+                    var extractOptions = new ExtractionOptions { Overwrite = true, ExtractFullPath = true, };
                     using var stream = File.OpenRead(archivePath);
                     using var archive = ReaderFactory.Open(stream);
 
@@ -373,9 +356,7 @@ public static partial class ArchiveHelper
                     }
                     catch (IOException e)
                     {
-                        Logger.Warn(
-                            $"Could not extract symbolic link, copying file instead: {e.Message}"
-                        );
+                        Logger.Warn($"Could not extract symbolic link, copying file instead: {e.Message}");
                     }
                 }
 

StabilityMatrix.Core/Helper/EventManager.cs

@@ -37,15 +37,14 @@ public class EventManager
     public event EventHandler<FilePath>? ImageFileAdded;
     public event EventHandler<LocalImageFile>? InferenceTextToImageRequested;
     public event EventHandler<LocalImageFile>? InferenceUpscaleRequested;
+    public event EventHandler<LocalImageFile>? InferenceImageToImageRequested;
+    public event EventHandler<LocalImageFile>? InferenceImageToVideoRequested;
 
-    public void OnGlobalProgressChanged(int progress) =>
-        GlobalProgressChanged?.Invoke(this, progress);
+    public void OnGlobalProgressChanged(int progress) => GlobalProgressChanged?.Invoke(this, progress);
 
-    public void OnInstalledPackagesChanged() =>
-        InstalledPackagesChanged?.Invoke(this, EventArgs.Empty);
+    public void OnInstalledPackagesChanged() => InstalledPackagesChanged?.Invoke(this, EventArgs.Empty);
 
-    public void OnOneClickInstallFinished(bool skipped) =>
-        OneClickInstallFinished?.Invoke(this, skipped);
+    public void OnOneClickInstallFinished(bool skipped) => OneClickInstallFinished?.Invoke(this, skipped);
 
     public void OnTeachingTooltipNeeded() => TeachingTooltipNeeded?.Invoke(this, EventArgs.Empty);
 
@@ -53,11 +52,9 @@ public class EventManager
 
     public void OnUpdateAvailable(UpdateInfo args) => UpdateAvailable?.Invoke(this, args);
 
-    public void OnPackageLaunchRequested(Guid packageId) =>
-        PackageLaunchRequested?.Invoke(this, packageId);
+    public void OnPackageLaunchRequested(Guid packageId) => PackageLaunchRequested?.Invoke(this, packageId);
 
-    public void OnScrollToBottomRequested() =>
-        ScrollToBottomRequested?.Invoke(this, EventArgs.Empty);
+    public void OnScrollToBottomRequested() => ScrollToBottomRequested?.Invoke(this, EventArgs.Empty);
 
     public void OnProgressChanged(ProgressItem progress) => ProgressChanged?.Invoke(this, progress);
 
@@ -83,4 +80,10 @@ public class EventManager
 
     public void OnInferenceUpscaleRequested(LocalImageFile imageFile) =>
         InferenceUpscaleRequested?.Invoke(this, imageFile);
+
+    public void OnInferenceImageToImageRequested(LocalImageFile imageFile) =>
+        InferenceImageToImageRequested?.Invoke(this, imageFile);
+
+    public void OnInferenceImageToVideoRequested(LocalImageFile imageFile) =>
+        InferenceImageToVideoRequested?.Invoke(this, imageFile);
 }

StabilityMatrix.Core/Helper/HardwareInfo/HardwareHelper.cs

@@ -15,7 +15,8 @@ public static partial class HardwareHelper
 
     private static IReadOnlyList<GpuInfo>? cachedGpuInfos;
 
-    private static readonly Lazy<IHardwareInfo> HardwareInfoLazy = new(() => new Hardware.Info.HardwareInfo());
+    private static readonly Lazy<IHardwareInfo> HardwareInfoLazy =
+        new(() => new Hardware.Info.HardwareInfo());
 
     public static IHardwareInfo HardwareInfo => HardwareInfoLazy.Value;
 
@@ -222,9 +223,10 @@ public static partial class HardwareHelper
     {
         var info = new CpuInfo();
 
-        using var processorKey = Registry
-            .LocalMachine
-            .OpenSubKey(@"Hardware\Description\System\CentralProcessor\0", RegistryKeyPermissionCheck.ReadSubTree);
+        using var processorKey = Registry.LocalMachine.OpenSubKey(
+            @"Hardware\Description\System\CentralProcessor\0",
+            RegistryKeyPermissionCheck.ReadSubTree
+        );
 
         if (processorKey?.GetValue("ProcessorNameString") is string processorName)
         {
@@ -240,7 +242,10 @@ public static partial class HardwareHelper
         {
             HardwareInfo.RefreshCPUList();
 
-            return new CpuInfo { ProcessorCaption = HardwareInfo.CpuList.FirstOrDefault()?.Caption.Trim() ?? "" };
+            return new CpuInfo
+            {
+                ProcessorCaption = HardwareInfo.CpuList.FirstOrDefault()?.Caption.Trim() ?? ""
+            };
         });
     }
 

StabilityMatrix.Core/Helper/ImageMetadata.cs

@@ -1,7 +1,12 @@
-using System.Text;
+using System.Diagnostics;
+using System.Text;
 using System.Text.Json;
+using ExifLibrary;
 using MetadataExtractor;
+using MetadataExtractor.Formats.Exif;
 using MetadataExtractor.Formats.Png;
+using MetadataExtractor.Formats.WebP;
+using Microsoft.VisualBasic;
 using StabilityMatrix.Core.Extensions;
 using StabilityMatrix.Core.Models;
 using StabilityMatrix.Core.Models.FileInterfaces;
@@ -13,10 +18,13 @@ public class ImageMetadata
 {
     private IReadOnlyList<Directory>? Directories { get; set; }
 
-    private static readonly byte[] PngHeader = { 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A };
+    private static readonly byte[] PngHeader = [0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A];
     private static readonly byte[] Idat = "IDAT"u8.ToArray();
     private static readonly byte[] Text = "tEXt"u8.ToArray();
 
+    private static readonly byte[] Riff = "RIFF"u8.ToArray();
+    private static readonly byte[] Webp = "WEBP"u8.ToArray();
+
     public static ImageMetadata ParseFile(FilePath path)
     {
         return new ImageMetadata { Directories = ImageMetadataReader.ReadMetadata(path) };
@@ -73,6 +81,14 @@ public class ImageMetadata
         string? ComfyNodes
     ) GetAllFileMetadata(FilePath filePath)
     {
+        if (filePath.Extension.Equals(".webp", StringComparison.OrdinalIgnoreCase))
+        {
+            var paramsJson = ReadTextChunkFromWebp(filePath, ExifDirectoryBase.TagImageDescription);
+            var smProj = ReadTextChunkFromWebp(filePath, ExifDirectoryBase.TagSoftware);
+
+            return (null, paramsJson, smProj, null);
+        }
+
         using var stream = filePath.Info.OpenRead();
         using var reader = new BinaryReader(stream);
 
@@ -227,4 +243,130 @@ public class ImageMetadata
         memoryStream.Position = 0;
         return memoryStream;
     }
+
+    /// <summary>
+    /// Reads an EXIF tag from a webp file and returns the value as string
+    /// </summary>
+    /// <param name="filePath">The webp file to read EXIF data from</param>
+    /// <param name="exifTag">Use <see cref="ExifDirectoryBase"/> constants for the tag you'd like to search for</param>
+    /// <returns></returns>
+    public static string ReadTextChunkFromWebp(FilePath filePath, int exifTag)
+    {
+        var exifDirs = WebPMetadataReader.ReadMetadata(filePath).OfType<ExifIfd0Directory>().FirstOrDefault();
+        return exifDirs is null ? string.Empty : exifDirs.GetString(exifTag) ?? string.Empty;
+    }
+
+    public static IEnumerable<byte> AddMetadataToWebp(
+        byte[] inputImage,
+        Dictionary<ExifTag, string> exifTagData
+    )
+    {
+        using var byteStream = new BinaryReader(new MemoryStream(inputImage));
+        byteStream.BaseStream.Position = 0;
+
+        // Read first 8 bytes and make sure they match the RIFF header
+        if (!byteStream.ReadBytes(4).SequenceEqual(Riff))
+        {
+            return Array.Empty<byte>();
+        }
+
+        // skip 4 bytes then read next 4 for webp header
+        byteStream.BaseStream.Position += 4;
+        if (!byteStream.ReadBytes(4).SequenceEqual(Webp))
+        {
+            return Array.Empty<byte>();
+        }
+
+        while (byteStream.BaseStream.Position < byteStream.BaseStream.Length - 4)
+        {
+            var chunkType = Encoding.UTF8.GetString(byteStream.ReadBytes(4));
+            var chunkSize = BitConverter.ToInt32(byteStream.ReadBytes(4).ToArray());
+
+            if (chunkType != "EXIF")
+            {
+                // skip chunk data
+                byteStream.BaseStream.Position += chunkSize;
+                continue;
+            }
+
+            var exifStart = byteStream.BaseStream.Position - 8;
+            var exifBytes = byteStream.ReadBytes(chunkSize);
+            Debug.WriteLine($"Found exif chunk of size {chunkSize}");
+
+            using var stream = new MemoryStream(exifBytes[6..]);
+            var img = new MyTiffFile(stream, Encoding.UTF8);
+
+            foreach (var (key, value) in exifTagData)
+            {
+                img.Properties.Set(key, value);
+            }
+
+            using var newStream = new MemoryStream();
+            img.Save(newStream);
+            newStream.Seek(0, SeekOrigin.Begin);
+            var newExifBytes = exifBytes[..6].Concat(newStream.ToArray());
+            var newExifSize = newExifBytes.Count();
+            var newChunkSize = BitConverter.GetBytes(newExifSize);
+            var newChunk = "EXIF"u8.ToArray().Concat(newChunkSize).Concat(newExifBytes).ToArray();
+
+            var inputEndIndex = (int)exifStart;
+            var newImage = inputImage[..inputEndIndex].Concat(newChunk).ToArray();
+
+            // webp or tiff or something requires even number of bytes
+            if (newImage.Length % 2 != 0)
+            {
+                newImage = newImage.Concat(new byte[] { 0x00 }).ToArray();
+            }
+
+            // no clue why the minus 8 is needed but it is
+            var newImageSize = BitConverter.GetBytes(newImage.Length - 8);
+            newImage[4] = newImageSize[0];
+            newImage[5] = newImageSize[1];
+            newImage[6] = newImageSize[2];
+            newImage[7] = newImageSize[3];
+            return newImage;
+        }
+
+        return Array.Empty<byte>();
+    }
+
+    private static byte[] GetExifChunks(FilePath imagePath)
+    {
+        using var byteStream = new BinaryReader(File.OpenRead(imagePath));
+        byteStream.BaseStream.Position = 0;
+
+        // Read first 8 bytes and make sure they match the RIFF header
+        if (!byteStream.ReadBytes(4).SequenceEqual(Riff))
+        {
+            return Array.Empty<byte>();
+        }
+
+        // skip 4 bytes then read next 4 for webp header
+        byteStream.BaseStream.Position += 4;
+        if (!byteStream.ReadBytes(4).SequenceEqual(Webp))
+        {
+            return Array.Empty<byte>();
+        }
+
+        while (byteStream.BaseStream.Position < byteStream.BaseStream.Length - 4)
+        {
+            var chunkType = Encoding.UTF8.GetString(byteStream.ReadBytes(4));
+            var chunkSize = BitConverter.ToInt32(byteStream.ReadBytes(4).ToArray());
+
+            if (chunkType != "EXIF")
+            {
+                // skip chunk data
+                byteStream.BaseStream.Position += chunkSize;
+                continue;
+            }
+
+            var exifStart = byteStream.BaseStream.Position;
+            var exifBytes = byteStream.ReadBytes(chunkSize);
+            var exif = Encoding.UTF8.GetString(exifBytes);
+            Debug.WriteLine($"Found exif chunk of size {chunkSize}");
+            return exifBytes;
+        }
+
+        return Array.Empty<byte>();
+    }
 }

StabilityMatrix.Core/Helper/MyTiffFile.cs

@@ -0,0 +1,6 @@
+using System.Text;
+using ExifLibrary;
+
+namespace StabilityMatrix.Core.Helper;
+
+public class MyTiffFile(MemoryStream stream, Encoding encoding) : TIFFFile(stream, encoding);

StabilityMatrix.Core/Helper/SharedFolders.cs

@@ -35,9 +35,7 @@ public class SharedFolders : ISharedFolders
         else
         {
             // Create parent directory if it doesn't exist, since CreateSymbolicLink doesn't seem to
-            new DirectoryPath(junctionDir)
-                .Parent
-                ?.Create();
+            new DirectoryPath(junctionDir).Parent?.Create();
             Directory.CreateSymbolicLink(junctionDir, targetDir);
         }
     }
@@ -195,7 +193,10 @@ public class SharedFolders : ISharedFolders
 
                 var sharedFolderMethod =
                     package.PreferredSharedFolderMethod ?? basePackage.RecommendedSharedFolderMethod;
-                basePackage.RemoveModelFolderLinks(package.FullPath, sharedFolderMethod).GetAwaiter().GetResult();
+                basePackage
+                    .RemoveModelFolderLinks(package.FullPath, sharedFolderMethod)
+                    .GetAwaiter()
+                    .GetResult();
             }
             catch (Exception e)
             {

StabilityMatrix.Core/Helper/Utilities.cs

@@ -13,8 +13,12 @@ public static class Utilities
             : $"{version.Major}.{version.Minor}.{version.Build}.{version.Revision}";
     }
 
-    public static void CopyDirectory(string sourceDir, string destinationDir, bool recursive,
-        bool includeReparsePoints = false)
+    public static void CopyDirectory(
+        string sourceDir,
+        string destinationDir,
+        bool recursive,
+        bool includeReparsePoints = false
+    )
     {
         // Get information about the source directory
         var dir = new DirectoryInfo(sourceDir);
@@ -35,11 +39,13 @@ public static class Utilities
         foreach (var file in dir.GetFiles())
         {
             var targetFilePath = Path.Combine(destinationDir, file.Name);
-            if (file.FullName == targetFilePath) continue;
+            if (file.FullName == targetFilePath)
+                continue;
             file.CopyTo(targetFilePath, true);
         }
 
-        if (!recursive) return;
+        if (!recursive)
+            return;
 
         // If recursive and copying subdirectories, recursively call this method
         foreach (var subDir in dirs)
@@ -48,4 +54,13 @@ public static class Utilities
             CopyDirectory(subDir.FullName, newDestinationDir, true);
         }
     }
+
+    public static MemoryStream? GetMemoryStreamFromFile(string filePath)
+    {
+        var fileBytes = File.ReadAllBytes(filePath);
+        var stream = new MemoryStream(fileBytes);
+        stream.Position = 0;
+
+        return stream;
+    }
 }

StabilityMatrix.Core/Models/Api/Comfy/NodeTypes/ConditioningConnections.cs

@@ -0,0 +1,12 @@
+namespace StabilityMatrix.Core.Models.Api.Comfy.NodeTypes;
+
+/// <summary>
+/// Combination of the positive and negative conditioning connections.
+/// </summary>
+public record ConditioningConnections(ConditioningNodeConnection Positive, ConditioningNodeConnection Negative)
+{
+    // Implicit from tuple
+    public static implicit operator ConditioningConnections(
+        (ConditioningNodeConnection Positive, ConditioningNodeConnection Negative) value
+    ) => new(value.Positive, value.Negative);
+}

StabilityMatrix.Core/Models/Api/Comfy/NodeTypes/ModelConnections.cs

@@ -0,0 +1,15 @@
+namespace StabilityMatrix.Core.Models.Api.Comfy.NodeTypes;
+
+/// <summary>
+/// Connections from a loaded model
+/// </summary>
+public record ModelConnections(string Name)
+{
+    public ModelNodeConnection? Model { get; set; }
+
+    public VAENodeConnection? VAE { get; set; }
+
+    public ClipNodeConnection? Clip { get; set; }
+
+    public ConditioningConnections? Conditioning { get; set; }
+}

StabilityMatrix.Core/Models/Api/Comfy/NodeTypes/NodeConnections.cs

@@ -18,6 +18,8 @@ public class ClipNodeConnection : NodeConnectionBase { }
 
 public class ControlNetNodeConnection : NodeConnectionBase { }
 
+public class ClipVisionNodeConnection : NodeConnectionBase { }
+
 public class SamplerNodeConnection : NodeConnectionBase { }
 
 public class SigmasNodeConnection : NodeConnectionBase { }

StabilityMatrix.Core/Models/Api/Comfy/Nodes/ComfyNodeBuilder.cs

@@ -119,6 +119,14 @@ public class ComfyNodeBuilder
         public required int Width { get; init; }
     }
 
+    public record CLIPSetLastLayer : ComfyTypedNodeBase<ClipNodeConnection>
+    {
+        public required ClipNodeConnection Clip { get; init; }
+
+        [Range(-24, -1)]
+        public int StopAtClipLayer { get; init; } = -1;
+    }
+
     public static NamedComfyNode<LatentNodeConnection> LatentFromBatch(
         string name,
         LatentNodeConnection samples,
@@ -217,6 +225,12 @@ public class ComfyNodeBuilder
         public required string CkptName { get; init; }
     }
 
+    public record ImageOnlyCheckpointLoader
+        : ComfyTypedNodeBase<ModelNodeConnection, ClipVisionNodeConnection, VAENodeConnection>
+    {
+        public required string CkptName { get; init; }
+    }
+
     public record FreeU : ComfyTypedNodeBase<ModelNodeConnection>
     {
         public required ModelNodeConnection Model { get; init; }
@@ -283,6 +297,36 @@ public class ComfyNodeBuilder
         public required double EndPercent { get; init; }
     }
 
+    public record SVD_img2vid_Conditioning
+        : ComfyTypedNodeBase<ConditioningNodeConnection, ConditioningNodeConnection, LatentNodeConnection>
+    {
+        public required ClipVisionNodeConnection ClipVision { get; init; }
+        public required ImageNodeConnection InitImage { get; init; }
+        public required VAENodeConnection Vae { get; init; }
+        public required int Width { get; init; }
+        public required int Height { get; init; }
+        public required int VideoFrames { get; init; }
+        public required int MotionBucketId { get; init; }
+        public required int Fps { get; set; }
+        public required double AugmentationLevel { get; init; }
+    }
+
+    public record VideoLinearCFGGuidance : ComfyTypedNodeBase<ModelNodeConnection>
+    {
+        public required ModelNodeConnection Model { get; init; }
+        public required double MinCfg { get; init; }
+    }
+
+    public record SaveAnimatedWEBP : ComfyTypedNodeBase
+    {
+        public required ImageNodeConnection Images { get; init; }
+        public required string FilenamePrefix { get; init; }
+        public required double Fps { get; init; }
+        public required bool Lossless { get; init; }
+        public required int Quality { get; init; }
+        public required string Method { get; init; }
+    }
+
     public ImageNodeConnection Lambda_LatentToImage(LatentNodeConnection latent, VAENodeConnection vae)
     {
         var name = GetUniqueName("VAEDecode");
@@ -725,18 +769,19 @@ public class ComfyNodeBuilder
         public int BatchSize { get; set; } = 1;
         public int? BatchIndex { get; set; }
 
-        public ModelNodeConnection? BaseModel { get; set; }
-        public VAENodeConnection? BaseVAE { get; set; }
         public ClipNodeConnection? BaseClip { get; set; }
+        public ClipVisionNodeConnection? BaseClipVision { get; set; }
+      
+        public Dictionary<string, ModelConnections> Models { get; } =
+            new() { ["Base"] = new ModelConnections("Base"), ["Refiner"] = new ModelConnections("Refiner") };
 
-        public ConditioningNodeConnection? BaseConditioning { get; set; }
-        public ConditioningNodeConnection? BaseNegativeConditioning { get; set; }
+        /// <summary>
+        /// ModelConnections from <see cref="Models"/> with <see cref="ModelConnections.Model"/> set
+        /// </summary>
+        public IEnumerable<ModelConnections> LoadedModels => Models.Values.Where(m => m.Model is not null);
 
-        public ModelNodeConnection? RefinerModel { get; set; }
-        public VAENodeConnection? RefinerVAE { get; set; }
-        public ClipNodeConnection? RefinerClip { get; set; }
-        public ConditioningNodeConnection? RefinerConditioning { get; set; }
-        public ConditioningNodeConnection? RefinerNegativeConditioning { get; set; }
+        public ModelConnections Base => Models["Base"];
+        public ModelConnections Refiner => Models["Refiner"];
 
         public PrimaryNodeConnection? Primary { get; set; }
         public VAENodeConnection? PrimaryVAE { get; set; }
@@ -751,24 +796,19 @@ public class ComfyNodeBuilder
 
         public ModelNodeConnection GetRefinerOrBaseModel()
         {
-            return RefinerModel ?? BaseModel ?? throw new NullReferenceException("No Model");
-        }
-
-        public ConditioningNodeConnection GetRefinerOrBaseConditioning()
-        {
-            return RefinerConditioning ?? BaseConditioning ?? throw new NullReferenceException("No Conditioning");
+            return Refiner.Model ?? Base.Model ?? throw new NullReferenceException("No Refiner or Base Model");
         }
 
-        public ConditioningNodeConnection GetRefinerOrBaseNegativeConditioning()
+        public ConditioningConnections GetRefinerOrBaseConditioning()
         {
-            return RefinerNegativeConditioning
-                ?? BaseNegativeConditioning
-                ?? throw new NullReferenceException("No Negative Conditioning");
+            return Refiner.Conditioning
+                ?? Base.Conditioning
+                ?? throw new NullReferenceException("No Refiner or Base Conditioning");
         }
 
         public VAENodeConnection GetDefaultVAE()
         {
-            return PrimaryVAE ?? RefinerVAE ?? BaseVAE ?? throw new NullReferenceException("No VAE");
+            return PrimaryVAE ?? Refiner.VAE ?? Base.VAE ?? throw new NullReferenceException("No VAE");
         }
     }
 

StabilityMatrix.Core/Models/Api/Comfy/Nodes/NodeDictionary.cs

@@ -25,9 +25,7 @@ public class NodeDictionary : Dictionary<string, ComfyNode>
         // Ensure new name does not exist
         if (ContainsKey(nameBase))
         {
-            throw new InvalidOperationException(
-                $"Initial unique name already exists for base {nameBase}"
-            );
+            throw new InvalidOperationException($"Initial unique name already exists for base {nameBase}");
         }
 
         _baseNameIndex.Add(nameBase, 1);

StabilityMatrix.Core/Models/Database/LocalImageFile.cs

@@ -1,4 +1,5 @@
 using DynamicData.Tests;
+using MetadataExtractor.Formats.Exif;
 using StabilityMatrix.Core.Helper;
 using StabilityMatrix.Core.Models.FileInterfaces;
 using JsonSerializer = System.Text.Json.JsonSerializer;
@@ -48,19 +49,20 @@ public record LocalImageFile
     /// </summary>
     public string FileNameWithoutExtension => Path.GetFileNameWithoutExtension(AbsolutePath);
 
-    public (
-        string? Parameters,
-        string? ParametersJson,
-        string? SMProject,
-        string? ComfyNodes
-    ) ReadMetadata()
+    public (string? Parameters, string? ParametersJson, string? SMProject, string? ComfyNodes) ReadMetadata()
     {
-        using var stream = new FileStream(
+        if (AbsolutePath.EndsWith("webp"))
+        {
+            var paramsJson = ImageMetadata.ReadTextChunkFromWebp(
                 AbsolutePath,
-            FileMode.Open,
-            FileAccess.Read,
-            FileShare.Read
+                ExifDirectoryBase.TagImageDescription
             );
+            var smProj = ImageMetadata.ReadTextChunkFromWebp(AbsolutePath, ExifDirectoryBase.TagSoftware);
+
+            return (null, paramsJson, smProj, null);
+        }
+
+        using var stream = new FileStream(AbsolutePath, FileMode.Open, FileAccess.Read, FileShare.Read);
         using var reader = new BinaryReader(stream);
 
         var parameters = ImageMetadata.ReadTextChunk(reader, "parameters");
@@ -79,8 +81,30 @@ public record LocalImageFile
     public static LocalImageFile FromPath(FilePath filePath)
     {
         // TODO: Support other types
-        const LocalImageFileType imageType =
-            LocalImageFileType.Inference | LocalImageFileType.TextToImage;
+        const LocalImageFileType imageType = LocalImageFileType.Inference | LocalImageFileType.TextToImage;
+
+        if (filePath.Extension.Equals(".webp", StringComparison.OrdinalIgnoreCase))
+        {
+            var paramsJson = ImageMetadata.ReadTextChunkFromWebp(
+                filePath,
+                ExifDirectoryBase.TagImageDescription
+            );
+            var parameters = string.IsNullOrWhiteSpace(paramsJson)
+                ? null
+                : JsonSerializer.Deserialize<GenerationParameters>(paramsJson);
+
+            filePath.Info.Refresh();
+
+            return new LocalImageFile
+            {
+                AbsolutePath = filePath,
+                ImageType = imageType,
+                CreatedAt = filePath.Info.CreationTimeUtc,
+                LastModifiedAt = filePath.Info.LastWriteTimeUtc,
+                GenerationParameters = parameters,
+                ImageSize = new Size(parameters?.Width ?? 0, parameters?.Height ?? 0)
+            };
+        }
 
         // Get metadata
         using var stream = filePath.Info.OpenRead();
@@ -116,5 +140,11 @@ public record LocalImageFile
     }
 
     public static readonly HashSet<string> SupportedImageExtensions =
-        new() { ".png", ".jpg", ".jpeg", ".webp" };
+    [
+        ".png",
+        ".jpg",
+        ".jpeg",
+        ".gif",
+        ".webp"
+    ];
 }

StabilityMatrix.Core/Models/Database/LocalModelFile.cs

@@ -29,6 +29,11 @@ public class LocalModelFile
     /// </summary>
     public string? PreviewImageRelativePath { get; set; }
 
+    /// <summary>
+    /// Optional preview image full path. Takes priority over <see cref="PreviewImageRelativePath"/>.
+    /// </summary>
+    public string? PreviewImageFullPath { get; set; }
+
     /// <summary>
     /// File name of the relative path.
     /// </summary>
@@ -45,7 +50,8 @@ public class LocalModelFile
     /// Relative file path from the shared folder type model directory.
     /// </summary>
     [BsonIgnore]
-    public string RelativePathFromSharedFolder => Path.GetRelativePath(SharedFolderType.GetStringValue(), RelativePath);
+    public string RelativePathFromSharedFolder =>
+        Path.GetRelativePath(SharedFolderType.GetStringValue(), RelativePath);
 
     public string GetFullPath(string rootModelDirectory)
     {
@@ -54,14 +60,29 @@ public class LocalModelFile
 
     public string? GetPreviewImageFullPath(string rootModelDirectory)
     {
-        return PreviewImageRelativePath == null ? null : Path.Combine(rootModelDirectory, PreviewImageRelativePath);
+        if (PreviewImageFullPath != null)
+            return PreviewImageFullPath;
+
+        return PreviewImageRelativePath == null
+            ? null
+            : Path.Combine(rootModelDirectory, PreviewImageRelativePath);
     }
 
     [BsonIgnore]
     public string FullPathGlobal => GetFullPath(GlobalConfig.LibraryDir.JoinDir("Models"));
 
     [BsonIgnore]
-    public string? PreviewImageFullPathGlobal => GetPreviewImageFullPath(GlobalConfig.LibraryDir.JoinDir("Models"));
+    public string? PreviewImageFullPathGlobal =>
+        PreviewImageFullPath ?? GetPreviewImageFullPath(GlobalConfig.LibraryDir.JoinDir("Models"));
+
+    [BsonIgnore]
+    public string DisplayModelName => ConnectedModelInfo?.ModelName ?? FileNameWithoutExtension;
+
+    [BsonIgnore]
+    public string DisplayModelVersion => ConnectedModelInfo?.VersionName ?? string.Empty;
+
+    [BsonIgnore]
+    public string DisplayModelFileName => FileName;
 
     protected bool Equals(LocalModelFile other)
     {
@@ -94,6 +115,6 @@ public class LocalModelFile
         ".pth",
         ".bin"
     ];
-    public static readonly HashSet<string> SupportedImageExtensions = [".png", ".jpg", ".jpeg", ".gif"];
+    public static readonly HashSet<string> SupportedImageExtensions = [".png", ".jpg", ".jpeg", ".webp"];
     public static readonly HashSet<string> SupportedMetadataExtensions = [".json"];
 }

StabilityMatrix.Core/Models/GenerationParameters.cs

@@ -20,6 +20,15 @@ public partial record GenerationParameters
     public int Width { get; set; }
     public string? ModelHash { get; set; }
     public string? ModelName { get; set; }
+    public int FrameCount { get; set; }
+    public int MotionBucketId { get; set; }
+    public int VideoQuality { get; set; }
+    public bool Lossless { get; set; }
+    public int Fps { get; set; }
+    public double OutputFps { get; set; }
+    public double MinCfg { get; set; }
+    public double AugmentationLevel { get; set; }
+    public string? VideoOutputMethod { get; set; }
 
     public static bool TryParse(
         string? text,

StabilityMatrix.Core/Processes/ProcessRunner.cs

@@ -92,7 +92,7 @@ public static class ProcessRunner
         else if (Compat.IsMacOS)
         {
             using var process = new Process();
-            process.StartInfo.FileName = "explorer";
+            process.StartInfo.FileName = "open";
             process.StartInfo.Arguments = $"-R {Quote(filePath)}";
             process.Start();
             await process.WaitForExitAsync().ConfigureAwait(false);
@@ -331,19 +331,10 @@ public static class ProcessRunner
     {
         // Quote arguments containing spaces
         var args = string.Join(" ", arguments.Where(s => !string.IsNullOrEmpty(s)).Select(Quote));
-        return StartAnsiProcess(
-            fileName,
-            args,
-            workingDirectory,
-            outputDataReceived,
-            environmentVariables
-        );
+        return StartAnsiProcess(fileName, args, workingDirectory, outputDataReceived, environmentVariables);
     }
 
-    public static async Task<ProcessResult> RunBashCommand(
-        string command,
-        string workingDirectory = ""
-    )
+    public static async Task<ProcessResult> RunBashCommand(string command, string workingDirectory = "")
     {
         // Escape any single quotes in the command
         var escapedCommand = command.Replace("\"", "\\\"");
@@ -381,10 +372,7 @@ public static class ProcessRunner
         };
     }
 
-    public static Task<ProcessResult> RunBashCommand(
-        IEnumerable<string> commands,
-        string workingDirectory = ""
-    )
+    public static Task<ProcessResult> RunBashCommand(IEnumerable<string> commands, string workingDirectory = "")
     {
         // Quote arguments containing spaces
         var args = string.Join(" ", commands.Select(Quote));
@@ -433,9 +421,7 @@ public static class ProcessRunner
         catch (SystemException) { }
 
         throw new ProcessException(
-            "Process "
-                + (processName == null ? "" : processName + " ")
-                + $"failed with exit-code {process.ExitCode}."
+            "Process " + (processName == null ? "" : processName + " ") + $"failed with exit-code {process.ExitCode}."
         );
     }
 }

StabilityMatrix.Core/Services/DownloadService.cs

@@ -43,7 +43,12 @@ public class DownloadService : IDownloadService
 
         await AddConditionalHeaders(client, new Uri(downloadUrl)).ConfigureAwait(false);
 
-        await using var file = new FileStream(downloadPath, FileMode.Create, FileAccess.Write, FileShare.None);
+        await using var file = new FileStream(
+            downloadPath,
+            FileMode.Create,
+            FileAccess.Write,
+            FileShare.None
+        );
 
         long contentLength = 0;
 
@@ -81,7 +86,9 @@ public class DownloadService : IDownloadService
             }
         }
 
-        await using var stream = await response.Content.ReadAsStreamAsync(cancellationToken).ConfigureAwait(false);
+        await using var stream = await response
+            .Content.ReadAsStreamAsync(cancellationToken)
+            .ConfigureAwait(false);
         var totalBytesRead = 0L;
         var buffer = new byte[BufferSize];
         while (true)
@@ -143,7 +150,12 @@ public class DownloadService : IDownloadService
             File.Create(downloadPath).Close();
         }
 
-        await using var file = new FileStream(downloadPath, FileMode.Append, FileAccess.Write, FileShare.None);
+        await using var file = new FileStream(
+            downloadPath,
+            FileMode.Append,
+            FileAccess.Write,
+            FileShare.None
+        );
 
         // Remaining content length
         long remainingContentLength = 0;
@@ -156,7 +168,9 @@ public class DownloadService : IDownloadService
         noRedirectRequest.Headers.Range = new RangeHeaderValue(existingFileSize, null);
 
         HttpResponseMessage? response = null;
-        foreach (var delay in Backoff.DecorrelatedJitterBackoffV2(TimeSpan.FromMilliseconds(50), retryCount: 4))
+        foreach (
+            var delay in Backoff.DecorrelatedJitterBackoffV2(TimeSpan.FromMilliseconds(50), retryCount: 4)
+        )
         {
             var noRedirectResponse = await noRedirectClient
                 .SendAsync(noRedirectRequest, HttpCompletionOption.ResponseHeadersRead, cancellationToken)
@@ -197,7 +211,9 @@ public class DownloadService : IDownloadService
 
         var isIndeterminate = remainingContentLength == 0;
 
-        await using var stream = await response.Content.ReadAsStreamAsync(cancellationToken).ConfigureAwait(false);
+        await using var stream = await response
+            .Content.ReadAsStreamAsync(cancellationToken)
+            .ConfigureAwait(false);
         var totalBytesRead = 0L;
         var buffer = new byte[BufferSize];
         while (true)
@@ -252,7 +268,9 @@ public class DownloadService : IDownloadService
 
         var contentLength = 0L;
 
-        foreach (var delay in Backoff.DecorrelatedJitterBackoffV2(TimeSpan.FromMilliseconds(50), retryCount: 3))
+        foreach (
+            var delay in Backoff.DecorrelatedJitterBackoffV2(TimeSpan.FromMilliseconds(50), retryCount: 3)
+        )
         {
             var response = await client
                 .GetAsync(downloadUrl, HttpCompletionOption.ResponseHeadersRead, cancellationToken)
@@ -303,7 +321,10 @@ public class DownloadService : IDownloadService
                     ObjectHash.GetStringSignature(civitApi.ApiToken),
                     url
                 );
-                client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", civitApi.ApiToken);
+                client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
+                    "Bearer",
+                    civitApi.ApiToken
+                );
             }
         }
     }

StabilityMatrix.Core/Services/MetadataImportService.cs

@@ -1,4 +1,5 @@
-using System.Text.Json;
+using System.Diagnostics;
+using System.Text.Json;
 using Microsoft.Extensions.Logging;
 using StabilityMatrix.Core.Attributes;
 using StabilityMatrix.Core.Helper;

StabilityMatrix.Core/Services/SettingsManager.cs

@@ -675,7 +675,20 @@ public class SettingsManager : ISettingsManager
                 SettingsSerializerContext.Default.Settings
             );
 
-            File.WriteAllBytes(SettingsPath, jsonBytes);
+            if (jsonBytes.Length == 0)
+            {
+                Logger.Error("JsonSerializer returned empty bytes for some reason");
+                return;
+            }
+
+            using var fs = File.Open(SettingsPath, FileMode.Open);
+            if (fs.CanWrite)
+            {
+                fs.Write(jsonBytes, 0, jsonBytes.Length);
+                fs.Flush();
+                fs.SetLength(jsonBytes.Length);
+            }
+            fs.Close();
         }
         finally
         {

StabilityMatrix.Core/StabilityMatrix.Core.csproj

@@ -25,9 +25,13 @@
       <PackageReference Include="DeviceId.Mac" Version="6.2.1" />
       <PackageReference Include="DeviceId.Windows" Version="6.5.0" />
       <PackageReference Include="DeviceId.Windows.Wmi" Version="6.5.1" />
+      <PackageReference Include="DotNet.Bundle" Version="0.9.13" />
       <PackageReference Include="DynamicData" Version="8.1.1" />
+      <PackageReference Include="ExifLibNet" Version="2.1.4" />
       <PackageReference Include="Hardware.Info" Version="100.0.0.1" />
       <PackageReference Include="JetBrains.Annotations" Version="2023.3.0" />
+      <PackageReference Include="KGySoft.Drawing.Core" Version="8.0.0" />
+      <PackageReference Include="KGySoft.Drawing.SkiaSharp" Version="8.0.0" />
       <PackageReference Include="LiteDB" Version="5.0.17" />
       <PackageReference Include="LiteDB.Async" Version="0.1.7" />
       <PackageReference Include="MetadataExtractor" Version="2.8.1" />
@@ -49,6 +53,7 @@
       <PackageReference Include="Semver" Version="3.0.0-beta.1" />
       <PackageReference Include="Sentry.NLog" Version="3.41.0" />
       <PackageReference Include="SharpCompress" Version="0.34.2" />
+      <PackageReference Include="SkiaSharp" Version="2.88.6" />
       <PackageReference Include="Websocket.Client" Version="5.0.0" />
       <PackageReference Include="YamlDotNet" Version="13.7.1" />
       <PackageReference Include="Yoh.Text.Json.NamingPolicies" Version="1.0.0" />