diff --git a/src/MrKWatkins.Assertions.Tests/EnumerableAssertionsTests.cs b/src/MrKWatkins.Assertions.Tests/EnumerableAssertionsTests.cs
index 986bcd9..d8aa953 100644
--- a/src/MrKWatkins.Assertions.Tests/EnumerableAssertionsTests.cs
+++ b/src/MrKWatkins.Assertions.Tests/EnumerableAssertionsTests.cs
@@ -132,6 +132,44 @@ public async Task SequenceEqual_Chain()
         await Assert.That(chain.And.Value).IsEqualTo(value);
     }
 
+    [Test]
+    public async Task SequenceEqual_Comparer()
+    {
+        var value = new List<string> { "a", "b", "c" };
+
+        await Assert.That(() => value.Should().SequenceEqual(new List<string> { "A", "B", "D" }, StringComparer.OrdinalIgnoreCase)).Throws<AssertionException>();
+        await Assert.That(() => value.Should().SequenceEqual(new List<string> { "A", "B", "C" }, StringComparer.OrdinalIgnoreCase)).ThrowsNothing();
+    }
+
+    [Test]
+    public async Task SequenceEqual_Comparer_Chain()
+    {
+        var value = new List<string> { "a", "b", "c" };
+
+        var chain = value.Should().SequenceEqual(new List<string> { "A", "B", "C" }, StringComparer.OrdinalIgnoreCase);
+        await Assert.That(chain.Value).IsEqualTo(value);
+        await Assert.That(chain.And.Value).IsEqualTo(value);
+    }
+
+    [Test]
+    public async Task SequenceEqual_Predicate()
+    {
+        var value = new List<string> { "a", "b", "c" };
+
+        await Assert.That(() => value.Should().SequenceEqual(new List<string> { "A", "B", "D" }, (a, b) => string.Equals(a, b, StringComparison.OrdinalIgnoreCase))).Throws<AssertionException>();
+        await Assert.That(() => value.Should().SequenceEqual(new List<string> { "A", "B", "C" }, (a, b) => string.Equals(a, b, StringComparison.OrdinalIgnoreCase))).ThrowsNothing();
+    }
+
+    [Test]
+    public async Task SequenceEqual_Predicate_Chain()
+    {
+        var value = new List<string> { "a", "b", "c" };
+
+        var chain = value.Should().SequenceEqual(new List<string> { "A", "B", "C" }, (a, b) => string.Equals(a, b, StringComparison.OrdinalIgnoreCase));
+        await Assert.That(chain.Value).IsEqualTo(value);
+        await Assert.That(chain.And.Value).IsEqualTo(value);
+    }
+
     [Test]
     public async Task NotSequenceEqual_Null()
     {
@@ -169,6 +207,46 @@ public async Task NotSequenceEqual_Chain()
         await Assert.That(chain.And.Value).IsEqualTo(value);
     }
 
+    [Test]
+    public async Task NotSequenceEqual_Comparer()
+    {
+        var value = new List<string> { "a", "b", "c" };
+
+        await Assert.That(() => value.Should().NotSequenceEqual(new List<string> { "A", "B", "C" }, StringComparer.OrdinalIgnoreCase)).Throws<AssertionException>()
+            .WithMessage("Value should not sequence equal [\"A\", \"B\", \"C\"].");
+        await Assert.That(() => value.Should().NotSequenceEqual(new List<string> { "A", "B", "D" }, StringComparer.OrdinalIgnoreCase)).ThrowsNothing();
+    }
+
+    [Test]
+    public async Task NotSequenceEqual_Comparer_Chain()
+    {
+        var value = new List<string> { "a", "b", "c" };
+
+        var chain = value.Should().NotSequenceEqual(new List<string> { "x", "y", "z" }, StringComparer.OrdinalIgnoreCase);
+        await Assert.That(chain.Value).IsEqualTo(value);
+        await Assert.That(chain.And.Value).IsEqualTo(value);
+    }
+
+    [Test]
+    public async Task NotSequenceEqual_Predicate()
+    {
+        var value = new List<string> { "a", "b", "c" };
+
+        await Assert.That(() => value.Should().NotSequenceEqual(new List<string> { "A", "B", "C" }, (a, b) => string.Equals(a, b, StringComparison.OrdinalIgnoreCase))).Throws<AssertionException>()
+            .WithMessage("Value should not sequence equal [\"A\", \"B\", \"C\"].");
+        await Assert.That(() => value.Should().NotSequenceEqual(new List<string> { "A", "B", "D" }, (a, b) => string.Equals(a, b, StringComparison.OrdinalIgnoreCase))).ThrowsNothing();
+    }
+
+    [Test]
+    public async Task NotSequenceEqual_Predicate_Chain()
+    {
+        var value = new List<string> { "a", "b", "c" };
+
+        var chain = value.Should().NotSequenceEqual(new List<string> { "x", "y", "z" }, (a, b) => string.Equals(a, b, StringComparison.OrdinalIgnoreCase));
+        await Assert.That(chain.Value).IsEqualTo(value);
+        await Assert.That(chain.And.Value).IsEqualTo(value);
+    }
+
     [Test]
     public async Task Contain_Null()
     {
diff --git a/src/MrKWatkins.Assertions.Tests/ObjectAssertionsTests.cs b/src/MrKWatkins.Assertions.Tests/ObjectAssertionsTests.cs
index 79d4442..c56f681 100644
--- a/src/MrKWatkins.Assertions.Tests/ObjectAssertionsTests.cs
+++ b/src/MrKWatkins.Assertions.Tests/ObjectAssertionsTests.cs
@@ -112,6 +112,72 @@ public async Task Equal_Chain()
         await Assert.That(and.Value).IsEqualTo(value);
     }
 
+    [Test]
+    public async Task Equal_Comparer_Null()
+    {
+        string? nullValue = null;
+        const string nonNullValue = "Not Null";
+
+        await Assert.That(() => nullValue.Should().Equal(nonNullValue, StringComparer.OrdinalIgnoreCase)).Throws<AssertionException>().WithMessage("Value should equal \"Not Null\" but was null.");
+        await Assert.That(() => nullValue.Should().Equal(nullValue, StringComparer.OrdinalIgnoreCase)).ThrowsNothing();
+    }
+
+    [Test]
+    public async Task Equal_Comparer()
+    {
+        const string value = "Test";
+        const string sameValueDifferentCase = "test";
+        const string otherValue = "Not Test";
+
+        await Assert.That(() => value.Should().Equal(otherValue, StringComparer.OrdinalIgnoreCase)).Throws<AssertionException>().WithMessage("Value should equal \"Not Test\" but was \"Test\".");
+        await Assert.That(() => value.Should().Equal(sameValueDifferentCase, StringComparer.OrdinalIgnoreCase)).ThrowsNothing();
+    }
+
+    [Test]
+    public async Task Equal_Comparer_Chain()
+    {
+        const string value = "Test";
+
+        var chain = value.Should().Equal("test", StringComparer.OrdinalIgnoreCase);
+        await Assert.That(chain.Value).IsEqualTo(value);
+
+        var and = chain.And;
+        await Assert.That(and.Value).IsEqualTo(value);
+    }
+
+    [Test]
+    public async Task Equal_Predicate_Null()
+    {
+        string? nullValue = null;
+        const string nonNullValue = "Not Null";
+
+        await Assert.That(() => nullValue.Should().Equal(nonNullValue, (a, b) => string.Equals(a, b, StringComparison.OrdinalIgnoreCase))).Throws<AssertionException>().WithMessage("Value should equal \"Not Null\" but was null.");
+        await Assert.That(() => nullValue.Should().Equal(nullValue, (a, b) => a is null && b is null)).ThrowsNothing();
+    }
+
+    [Test]
+    public async Task Equal_Predicate()
+    {
+        const string value = "Test";
+        const string sameValueDifferentCase = "test";
+        const string otherValue = "Not Test";
+
+        await Assert.That(() => value.Should().Equal(otherValue, (a, b) => string.Equals(a, b, StringComparison.OrdinalIgnoreCase))).Throws<AssertionException>().WithMessage("Value should equal \"Not Test\" but was \"Test\".");
+        await Assert.That(() => value.Should().Equal(sameValueDifferentCase, (a, b) => string.Equals(a, b, StringComparison.OrdinalIgnoreCase))).ThrowsNothing();
+    }
+
+    [Test]
+    public async Task Equal_Predicate_Chain()
+    {
+        const string value = "Test";
+
+        var chain = value.Should().Equal("test", (a, b) => string.Equals(a, b, StringComparison.OrdinalIgnoreCase));
+        await Assert.That(chain.Value).IsEqualTo(value);
+
+        var and = chain.And;
+        await Assert.That(and.Value).IsEqualTo(value);
+    }
+
     [Test]
     public async Task NotEqual_Null()
     {
@@ -145,6 +211,74 @@ public async Task NotEqual_Chain()
         await Assert.That(and.Value).IsEqualTo(value);
     }
 
+    [Test]
+    public async Task NotEqual_Comparer_Null()
+    {
+        string? nullValue = null;
+        const string nonNullValue = "Not Null";
+
+        await Assert.That(() => nullValue.Should().NotEqual(nonNullValue, StringComparer.OrdinalIgnoreCase)).ThrowsNothing();
+        await Assert.That(() => nullValue.Should().NotEqual(nullValue, StringComparer.OrdinalIgnoreCase)).Throws<AssertionException>().WithMessage("Value should not equal null.");
+    }
+
+    [Test]
+    public async Task NotEqual_Comparer()
+    {
+        const string value = "Test";
+        const string sameValueDifferentCase = "test";
+        const string otherValue = "Not Test";
+
+        await Assert.That(() => value.Should().NotEqual(otherValue, StringComparer.OrdinalIgnoreCase)).ThrowsNothing();
+        await Assert.That(() => value.Should().NotEqual(sameValueDifferentCase, StringComparer.OrdinalIgnoreCase)).Throws<AssertionException>().WithMessage("Value should not equal \"test\".");
+    }
+
+    [Test]
+    public async Task NotEqual_Comparer_Chain()
+    {
+        const string value = "Test";
+        const string otherValue = "Not Test";
+
+        var chain = value.Should().NotEqual(otherValue, StringComparer.OrdinalIgnoreCase);
+        await Assert.That(chain.Value).IsEqualTo(value);
+
+        var and = chain.And;
+        await Assert.That(and.Value).IsEqualTo(value);
+    }
+
+    [Test]
+    public async Task NotEqual_Predicate_Null()
+    {
+        string? nullValue = null;
+        const string nonNullValue = "Not Null";
+
+        await Assert.That(() => nullValue.Should().NotEqual(nonNullValue, (a, b) => string.Equals(a, b, StringComparison.OrdinalIgnoreCase))).ThrowsNothing();
+        await Assert.That(() => nullValue.Should().NotEqual(nullValue, (a, b) => a is null && b is null)).Throws<AssertionException>().WithMessage("Value should not equal null.");
+    }
+
+    [Test]
+    public async Task NotEqual_Predicate()
+    {
+        const string value = "Test";
+        const string sameValueDifferentCase = "test";
+        const string otherValue = "Not Test";
+
+        await Assert.That(() => value.Should().NotEqual(otherValue, (a, b) => string.Equals(a, b, StringComparison.OrdinalIgnoreCase))).ThrowsNothing();
+        await Assert.That(() => value.Should().NotEqual(sameValueDifferentCase, (a, b) => string.Equals(a, b, StringComparison.OrdinalIgnoreCase))).Throws<AssertionException>().WithMessage("Value should not equal \"test\".");
+    }
+
+    [Test]
+    public async Task NotEqual_Predicate_Chain()
+    {
+        const string value = "Test";
+        const string otherValue = "Not Test";
+
+        var chain = value.Should().NotEqual(otherValue, (a, b) => string.Equals(a, b, StringComparison.OrdinalIgnoreCase));
+        await Assert.That(chain.Value).IsEqualTo(value);
+
+        var and = chain.And;
+        await Assert.That(and.Value).IsEqualTo(value);
+    }
+
     [Test]
     public async Task BeTheSameInstanceAs()
     {
diff --git a/src/MrKWatkins.Assertions.Tests/ReadOnlySpanAssertionsTests.cs b/src/MrKWatkins.Assertions.Tests/ReadOnlySpanAssertionsTests.cs
index 5e13cbd..83ab968 100644
--- a/src/MrKWatkins.Assertions.Tests/ReadOnlySpanAssertionsTests.cs
+++ b/src/MrKWatkins.Assertions.Tests/ReadOnlySpanAssertionsTests.cs
@@ -128,6 +128,42 @@ public async Task SequenceEqual_Chain_And_Value()
         await Assert.That(and.Value == value).IsTrue();
     }
 
+    [Test]
+    public async Task SequenceEqual_Comparer()
+    {
+        await Assert.That(() =>
+        {
+            ReadOnlySpan<string> value = ["a", "b", "c"];
+            ReadOnlySpan<string> different = ["A", "B", "D"];
+            value.Should().SequenceEqual(different, StringComparer.OrdinalIgnoreCase);
+        }).Throws<AssertionException>();
+
+        await Assert.That(() =>
+        {
+            ReadOnlySpan<string> value = ["a", "b", "c"];
+            ReadOnlySpan<string> same = ["A", "B", "C"];
+            value.Should().SequenceEqual(same, StringComparer.OrdinalIgnoreCase);
+        }).ThrowsNothing();
+    }
+
+    [Test]
+    public async Task SequenceEqual_Predicate()
+    {
+        await Assert.That(() =>
+        {
+            ReadOnlySpan<string> value = ["a", "b", "c"];
+            ReadOnlySpan<string> different = ["A", "B", "D"];
+            value.Should().SequenceEqual(different, (a, b) => string.Equals(a, b, StringComparison.OrdinalIgnoreCase));
+        }).Throws<AssertionException>();
+
+        await Assert.That(() =>
+        {
+            ReadOnlySpan<string> value = ["a", "b", "c"];
+            ReadOnlySpan<string> same = ["A", "B", "C"];
+            value.Should().SequenceEqual(same, (a, b) => string.Equals(a, b, StringComparison.OrdinalIgnoreCase));
+        }).ThrowsNothing();
+    }
+
     [Test]
     public async Task SequenceEqual_IEnumerable()
     {
@@ -242,6 +278,42 @@ public async Task SequenceEqual_IEnumerable_Chain_And_Value()
         await Assert.That(and.Value == value).IsTrue();
     }
 
+    [Test]
+    public async Task SequenceEqual_IEnumerable_Comparer()
+    {
+        await Assert.That(() =>
+        {
+            ReadOnlySpan<string> value = ["a", "b", "c"];
+            IReadOnlyList<string> different = ["A", "B", "D"];
+            value.Should().SequenceEqual(different, StringComparer.OrdinalIgnoreCase);
+        }).Throws<AssertionException>();
+
+        await Assert.That(() =>
+        {
+            ReadOnlySpan<string> value = ["a", "b", "c"];
+            IReadOnlyList<string> same = ["A", "B", "C"];
+            value.Should().SequenceEqual(same, StringComparer.OrdinalIgnoreCase);
+        }).ThrowsNothing();
+    }
+
+    [Test]
+    public async Task SequenceEqual_IEnumerable_Predicate()
+    {
+        await Assert.That(() =>
+        {
+            ReadOnlySpan<string> value = ["a", "b", "c"];
+            IReadOnlyList<string> different = ["A", "B", "D"];
+            value.Should().SequenceEqual(different, (a, b) => string.Equals(a, b, StringComparison.OrdinalIgnoreCase));
+        }).Throws<AssertionException>();
+
+        await Assert.That(() =>
+        {
+            ReadOnlySpan<string> value = ["a", "b", "c"];
+            IReadOnlyList<string> same = ["A", "B", "C"];
+            value.Should().SequenceEqual(same, (a, b) => string.Equals(a, b, StringComparison.OrdinalIgnoreCase));
+        }).ThrowsNothing();
+    }
+
     [Test]
     public async Task NotSequenceEqual()
     {
@@ -308,6 +380,42 @@ public async Task NotSequenceEqual_Chain_And_Value()
         await Assert.That(and.Value == value).IsTrue();
     }
 
+    [Test]
+    public async Task NotSequenceEqual_Comparer()
+    {
+        await Assert.That(() =>
+        {
+            ReadOnlySpan<string> value = ["a", "b", "c"];
+            ReadOnlySpan<string> same = ["A", "B", "C"];
+            value.Should().NotSequenceEqual(same, StringComparer.OrdinalIgnoreCase);
+        }).Throws<AssertionException>();
+
+        await Assert.That(() =>
+        {
+            ReadOnlySpan<string> value = ["a", "b", "c"];
+            ReadOnlySpan<string> different = ["A", "B", "D"];
+            value.Should().NotSequenceEqual(different, StringComparer.OrdinalIgnoreCase);
+        }).ThrowsNothing();
+    }
+
+    [Test]
+    public async Task NotSequenceEqual_Predicate()
+    {
+        await Assert.That(() =>
+        {
+            ReadOnlySpan<string> value = ["a", "b", "c"];
+            ReadOnlySpan<string> same = ["A", "B", "C"];
+            value.Should().NotSequenceEqual(same, (a, b) => string.Equals(a, b, StringComparison.OrdinalIgnoreCase));
+        }).Throws<AssertionException>();
+
+        await Assert.That(() =>
+        {
+            ReadOnlySpan<string> value = ["a", "b", "c"];
+            ReadOnlySpan<string> different = ["A", "B", "D"];
+            value.Should().NotSequenceEqual(different, (a, b) => string.Equals(a, b, StringComparison.OrdinalIgnoreCase));
+        }).ThrowsNothing();
+    }
+
     [Test]
     public async Task NotSequenceEqual_IEnumerable()
     {
@@ -366,4 +474,40 @@ public async Task NotSequenceEqual_IEnumerable_Chain_And_Value()
         var and = value.Should().NotSequenceEqual(notSequenceEqual).And;
         await Assert.That(and.Value == value).IsTrue();
     }
+
+    [Test]
+    public async Task NotSequenceEqual_IEnumerable_Comparer()
+    {
+        await Assert.That(() =>
+        {
+            ReadOnlySpan<string> value = ["a", "b", "c"];
+            IReadOnlyList<string> same = ["A", "B", "C"];
+            value.Should().NotSequenceEqual(same, StringComparer.OrdinalIgnoreCase);
+        }).Throws<AssertionException>();
+
+        await Assert.That(() =>
+        {
+            ReadOnlySpan<string> value = ["a", "b", "c"];
+            IReadOnlyList<string> different = ["A", "B", "D"];
+            value.Should().NotSequenceEqual(different, StringComparer.OrdinalIgnoreCase);
+        }).ThrowsNothing();
+    }
+
+    [Test]
+    public async Task NotSequenceEqual_IEnumerable_Predicate()
+    {
+        await Assert.That(() =>
+        {
+            ReadOnlySpan<string> value = ["a", "b", "c"];
+            IReadOnlyList<string> same = ["A", "B", "C"];
+            value.Should().NotSequenceEqual(same, (a, b) => string.Equals(a, b, StringComparison.OrdinalIgnoreCase));
+        }).Throws<AssertionException>();
+
+        await Assert.That(() =>
+        {
+            ReadOnlySpan<string> value = ["a", "b", "c"];
+            IReadOnlyList<string> different = ["A", "B", "D"];
+            value.Should().NotSequenceEqual(different, (a, b) => string.Equals(a, b, StringComparison.OrdinalIgnoreCase));
+        }).ThrowsNothing();
+    }
 }
\ No newline at end of file
diff --git a/src/MrKWatkins.Assertions/EnumerableAssertions.cs b/src/MrKWatkins.Assertions/EnumerableAssertions.cs
index d609d8d..2c8948e 100644
--- a/src/MrKWatkins.Assertions/EnumerableAssertions.cs
+++ b/src/MrKWatkins.Assertions/EnumerableAssertions.cs
@@ -54,7 +54,31 @@ public ObjectAssertionsChain<T> ContainSingle([InstantHandle] Func<T, bool> pred
     /// <param name="expected">The expected elements.</param>
     /// <returns>An <see cref="EnumerableAssertionsChain{TEnumerable, T}" /> for chaining further assertions.</returns>
     [SuppressMessage("ReSharper", "PossibleMultipleEnumeration")]
-    public EnumerableAssertionsChain<TEnumerable, T> SequenceEqual([InstantHandle] params IEnumerable<T?> expected)
+    public EnumerableAssertionsChain<TEnumerable, T> SequenceEqual([InstantHandle] params IEnumerable<T?> expected) =>
+        SequenceEqualCore(expected, EqualityComparer<T>.Default.Equals);
+
+    /// <summary>
+    /// Asserts that the enumerable is sequence equal to the expected elements using the specified equality comparer.
+    /// </summary>
+    /// <param name="expected">The expected elements.</param>
+    /// <param name="comparer">The equality comparer to use for element comparison.</param>
+    /// <returns>An <see cref="EnumerableAssertionsChain{TEnumerable, T}" /> for chaining further assertions.</returns>
+    [SuppressMessage("ReSharper", "PossibleMultipleEnumeration")]
+    public EnumerableAssertionsChain<TEnumerable, T> SequenceEqual([InstantHandle] IEnumerable<T?> expected, IEqualityComparer<T> comparer) =>
+        SequenceEqualCore(expected, comparer.Equals);
+
+    /// <summary>
+    /// Asserts that the enumerable is sequence equal to the expected elements using the specified predicate.
+    /// </summary>
+    /// <param name="expected">The expected elements.</param>
+    /// <param name="predicate">The predicate to use for element comparison.</param>
+    /// <returns>An <see cref="EnumerableAssertionsChain{TEnumerable, T}" /> for chaining further assertions.</returns>
+    [SuppressMessage("ReSharper", "PossibleMultipleEnumeration")]
+    public EnumerableAssertionsChain<TEnumerable, T> SequenceEqual([InstantHandle] IEnumerable<T?> expected, Func<T?, T?, bool> predicate) =>
+        SequenceEqualCore(expected, predicate);
+
+    [SuppressMessage("ReSharper", "PossibleMultipleEnumeration")]
+    private EnumerableAssertionsChain<TEnumerable, T> SequenceEqualCore(IEnumerable<T?> expected, Func<T?, T?, bool> equals)
     {
         NotBeNull();
 
@@ -68,7 +92,6 @@ public EnumerableAssertionsChain<TEnumerable, T> SequenceEqual([InstantHandle] p
 
         var actualList = new List<T>();
         var expectedList = new List<T?>();
-        var equalityComparer = EqualityComparer<T>.Default;
 
         using var actualEnumerator = Value.GetEnumerator();
         using var expectedEnumerator = expected.GetEnumerator();
@@ -94,7 +117,7 @@ public EnumerableAssertionsChain<TEnumerable, T> SequenceEqual([InstantHandle] p
                     $"Value {Format.Enumerable(Value)} should sequence equal {Format.Collection(expectedList)} but it has more elements than the expected {expectedList.Count}.");
             }
 
-            if (!equalityComparer.Equals(actualEnumerator.Current, expectedEnumerator.Current))
+            if (!equals(actualEnumerator.Current, expectedEnumerator.Current))
             {
                 var index = actualList.Count - 1;
                 throw Verify.CreateException(
@@ -129,6 +152,63 @@ public EnumerableAssertionsChain<TEnumerable, T> NotSequenceEqual(params IEnumer
         return new EnumerableAssertionsChain<TEnumerable, T>(this);
     }
 
+    /// <summary>
+    /// Asserts that the enumerable is not sequence equal to the expected elements using the specified equality comparer.
+    /// </summary>
+    /// <param name="expected">The elements the enumerable should not be sequence equal to.</param>
+    /// <param name="comparer">The equality comparer to use for element comparison.</param>
+    /// <returns>An <see cref="EnumerableAssertionsChain{TEnumerable, T}" /> for chaining further assertions.</returns>
+    [SuppressMessage("ReSharper", "PossibleMultipleEnumeration")]
+    public EnumerableAssertionsChain<TEnumerable, T> NotSequenceEqual(IEnumerable<T> expected, IEqualityComparer<T> comparer)
+    {
+        NotBeNull();
+
+        if (Value.SequenceEqual(expected, comparer))
+        {
+            throw Verify.CreateException($"Value should not sequence equal {Format.Enumerable(expected)}.");
+        }
+
+        return new EnumerableAssertionsChain<TEnumerable, T>(this);
+    }
+
+    /// <summary>
+    /// Asserts that the enumerable is not sequence equal to the expected elements using the specified predicate.
+    /// </summary>
+    /// <param name="expected">The elements the enumerable should not be sequence equal to.</param>
+    /// <param name="predicate">The predicate to use for element comparison.</param>
+    /// <returns>An <see cref="EnumerableAssertionsChain{TEnumerable, T}" /> for chaining further assertions.</returns>
+    [SuppressMessage("ReSharper", "PossibleMultipleEnumeration")]
+    public EnumerableAssertionsChain<TEnumerable, T> NotSequenceEqual(IEnumerable<T> expected, Func<T?, T?, bool> predicate)
+    {
+        NotBeNull();
+
+        using var actualEnumerator = Value.GetEnumerator();
+        using var expectedEnumerator = expected.GetEnumerator();
+
+        while (true)
+        {
+            var actualHasNext = actualEnumerator.MoveNext();
+            var expectedHasNext = expectedEnumerator.MoveNext();
+
+            if (!actualHasNext && !expectedHasNext)
+            {
+                break;
+            }
+
+            if (!actualHasNext || !expectedHasNext)
+            {
+                return new EnumerableAssertionsChain<TEnumerable, T>(this);
+            }
+
+            if (!predicate(actualEnumerator.Current, expectedEnumerator.Current))
+            {
+                return new EnumerableAssertionsChain<TEnumerable, T>(this);
+            }
+        }
+
+        throw Verify.CreateException($"Value should not sequence equal {Format.Enumerable(expected)}.");
+    }
+
     /// <summary>
     /// Asserts that the enumerable contains the specified item.
     /// </summary>
diff --git a/src/MrKWatkins.Assertions/ObjectAssertions.cs b/src/MrKWatkins.Assertions/ObjectAssertions.cs
index a9bb3f1..a19948f 100644
--- a/src/MrKWatkins.Assertions/ObjectAssertions.cs
+++ b/src/MrKWatkins.Assertions/ObjectAssertions.cs
@@ -53,6 +53,46 @@ public ObjectAssertionsChain<T> Equal(T? expected)
         return new ObjectAssertionsChain<T>(this);
     }
 
+    /// <summary>
+    /// Asserts that the value is equal to the expected value using the specified equality comparer.
+    /// </summary>
+    /// <param name="expected">The expected value.</param>
+    /// <param name="comparer">The equality comparer to use for the comparison.</param>
+    /// <returns>An <see cref="ObjectAssertionsChain{T}" /> for chaining further assertions.</returns>
+    public ObjectAssertionsChain<T> Equal(T? expected, IEqualityComparer<T> comparer)
+    {
+        if (Value is null)
+        {
+            Verify.That(expected is null, $"Value should equal {expected} but was null.");
+        }
+        else
+        {
+            Verify.That(comparer.Equals(Value, expected), $"Value should equal {expected} but was {Value}.");
+        }
+
+        return new ObjectAssertionsChain<T>(this);
+    }
+
+    /// <summary>
+    /// Asserts that the value is equal to the expected value using the specified predicate.
+    /// </summary>
+    /// <param name="expected">The expected value.</param>
+    /// <param name="predicate">The predicate to use for the comparison.</param>
+    /// <returns>An <see cref="ObjectAssertionsChain{T}" /> for chaining further assertions.</returns>
+    public ObjectAssertionsChain<T> Equal(T? expected, Func<T?, T?, bool> predicate)
+    {
+        if (Value is null)
+        {
+            Verify.That(predicate(Value, expected), $"Value should equal {expected} but was null.");
+        }
+        else
+        {
+            Verify.That(predicate(Value, expected), $"Value should equal {expected} but was {Value}.");
+        }
+
+        return new ObjectAssertionsChain<T>(this);
+    }
+
     /// <summary>
     /// Asserts that the value is not equal to the expected value using the default equality comparer.
     /// </summary>
@@ -72,6 +112,39 @@ public ObjectAssertionsChain<T> NotEqual(T? expected)
         return new ObjectAssertionsChain<T>(this);
     }
 
+    /// <summary>
+    /// Asserts that the value is not equal to the expected value using the specified equality comparer.
+    /// </summary>
+    /// <param name="expected">The value that is not expected.</param>
+    /// <param name="comparer">The equality comparer to use for the comparison.</param>
+    /// <returns>An <see cref="ObjectAssertionsChain{T}" /> for chaining further assertions.</returns>
+    public ObjectAssertionsChain<T> NotEqual(T? expected, IEqualityComparer<T> comparer)
+    {
+        if (Value is null)
+        {
+            Verify.That(expected is not null, "Value should not equal null.");
+        }
+        else
+        {
+            Verify.That(!comparer.Equals(Value, expected), $"Value should not equal {expected}.");
+        }
+
+        return new ObjectAssertionsChain<T>(this);
+    }
+
+    /// <summary>
+    /// Asserts that the value is not equal to the expected value using the specified predicate.
+    /// </summary>
+    /// <param name="expected">The value that is not expected.</param>
+    /// <param name="predicate">The predicate to use for the comparison.</param>
+    /// <returns>An <see cref="ObjectAssertionsChain{T}" /> for chaining further assertions.</returns>
+    public ObjectAssertionsChain<T> NotEqual(T? expected, Func<T?, T?, bool> predicate)
+    {
+        Verify.That(!predicate(Value, expected), $"Value should not equal {expected}.");
+
+        return new ObjectAssertionsChain<T>(this);
+    }
+
     /// <summary>
     /// Asserts that the value is the same instance as the expected value.
     /// </summary>
diff --git a/src/MrKWatkins.Assertions/ReadOnlySpanAssertions.cs b/src/MrKWatkins.Assertions/ReadOnlySpanAssertions.cs
index 0562f99..ce33c33 100644
--- a/src/MrKWatkins.Assertions/ReadOnlySpanAssertions.cs
+++ b/src/MrKWatkins.Assertions/ReadOnlySpanAssertions.cs
@@ -63,6 +63,62 @@ public ReadOnlySpanAssertionsChain<T> SequenceEqual(params ReadOnlySpan<T> expec
         return new ReadOnlySpanAssertionsChain<T>(this);
     }
 
+    /// <summary>
+    /// Asserts that the span is sequence equal to the expected elements using the specified equality comparer.
+    /// </summary>
+    /// <param name="expected">The expected elements.</param>
+    /// <param name="comparer">The equality comparer to use for element comparison.</param>
+    /// <returns>A <see cref="ReadOnlySpanAssertionsChain{TItem}" /> for chaining further assertions.</returns>
+    public ReadOnlySpanAssertionsChain<T> SequenceEqual(ReadOnlySpan<T> expected, IEqualityComparer<T> comparer)
+    {
+        if (Value.Length != expected.Length)
+        {
+            throw Verify.CreateException(
+                $"Value {Format.Value(Value)} should sequence equal {Format.Value(expected)} but it has {Value.Length} element{(Value.Length == 1 ? "" : "s")} rather than the expected {expected.Length}.");
+        }
+
+        for (var f = 0; f < Value.Length; f++)
+        {
+            var actualItem = Value[f];
+            var expectedItem = expected[f];
+            if (!comparer.Equals(actualItem, expectedItem))
+            {
+                throw Verify.CreateException(
+                    $"Value {Format.Value(Value, f)} should sequence equal {Format.Value(expected, f)} but it differs at index {f}.");
+            }
+        }
+
+        return new ReadOnlySpanAssertionsChain<T>(this);
+    }
+
+    /// <summary>
+    /// Asserts that the span is sequence equal to the expected elements using the specified predicate.
+    /// </summary>
+    /// <param name="expected">The expected elements.</param>
+    /// <param name="predicate">The predicate to use for element comparison.</param>
+    /// <returns>A <see cref="ReadOnlySpanAssertionsChain{TItem}" /> for chaining further assertions.</returns>
+    public ReadOnlySpanAssertionsChain<T> SequenceEqual(ReadOnlySpan<T> expected, Func<T?, T?, bool> predicate)
+    {
+        if (Value.Length != expected.Length)
+        {
+            throw Verify.CreateException(
+                $"Value {Format.Value(Value)} should sequence equal {Format.Value(expected)} but it has {Value.Length} element{(Value.Length == 1 ? "" : "s")} rather than the expected {expected.Length}.");
+        }
+
+        for (var f = 0; f < Value.Length; f++)
+        {
+            var actualItem = Value[f];
+            var expectedItem = expected[f];
+            if (!predicate(actualItem, expectedItem))
+            {
+                throw Verify.CreateException(
+                    $"Value {Format.Value(Value, f)} should sequence equal {Format.Value(expected, f)} but it differs at index {f}.");
+            }
+        }
+
+        return new ReadOnlySpanAssertionsChain<T>(this);
+    }
+
     /// <summary>
     /// Asserts that the span is not sequence equal to the expected elements.
     /// </summary>
@@ -78,14 +134,83 @@ public ReadOnlySpanAssertionsChain<T> NotSequenceEqual(params ReadOnlySpan<T> ex
         return new ReadOnlySpanAssertionsChain<T>(this);
     }
 
+    /// <summary>
+    /// Asserts that the span is not sequence equal to the expected elements using the specified equality comparer.
+    /// </summary>
+    /// <param name="expected">The elements the span should not be sequence equal to.</param>
+    /// <param name="comparer">The equality comparer to use for element comparison.</param>
+    /// <returns>A <see cref="ReadOnlySpanAssertionsChain{TItem}" /> for chaining further assertions.</returns>
+    public ReadOnlySpanAssertionsChain<T> NotSequenceEqual(ReadOnlySpan<T> expected, IEqualityComparer<T> comparer)
+    {
+        if (Value.Length != expected.Length)
+        {
+            return new ReadOnlySpanAssertionsChain<T>(this);
+        }
+
+        for (var f = 0; f < Value.Length; f++)
+        {
+            if (!comparer.Equals(Value[f], expected[f]))
+            {
+                return new ReadOnlySpanAssertionsChain<T>(this);
+            }
+        }
+
+        throw Verify.CreateException($"Value should not sequence equal {Format.Value(expected)}.");
+    }
+
+    /// <summary>
+    /// Asserts that the span is not sequence equal to the expected elements using the specified predicate.
+    /// </summary>
+    /// <param name="expected">The elements the span should not be sequence equal to.</param>
+    /// <param name="predicate">The predicate to use for element comparison.</param>
+    /// <returns>A <see cref="ReadOnlySpanAssertionsChain{TItem}" /> for chaining further assertions.</returns>
+    public ReadOnlySpanAssertionsChain<T> NotSequenceEqual(ReadOnlySpan<T> expected, Func<T?, T?, bool> predicate)
+    {
+        if (Value.Length != expected.Length)
+        {
+            return new ReadOnlySpanAssertionsChain<T>(this);
+        }
+
+        for (var f = 0; f < Value.Length; f++)
+        {
+            if (!predicate(Value[f], expected[f]))
+            {
+                return new ReadOnlySpanAssertionsChain<T>(this);
+            }
+        }
+
+        throw Verify.CreateException($"Value should not sequence equal {Format.Value(expected)}.");
+    }
+
     /// <summary>
     /// Asserts that the span is sequence equal to the expected enumerable elements.
     /// </summary>
     /// <param name="expected">The expected elements.</param>
     /// <returns>A <see cref="ReadOnlySpanAssertionsChain{TItem}" /> for chaining further assertions.</returns>
-    public ReadOnlySpanAssertionsChain<T> SequenceEqual([InstantHandle] IEnumerable<T> expected)
+    public ReadOnlySpanAssertionsChain<T> SequenceEqual([InstantHandle] IEnumerable<T> expected) =>
+        SequenceEqualEnumerableCore(expected, EqualityComparer<T>.Default.Equals);
+
+    /// <summary>
+    /// Asserts that the span is sequence equal to the expected enumerable elements using the specified equality comparer.
+    /// </summary>
+    /// <param name="expected">The expected elements.</param>
+    /// <param name="comparer">The equality comparer to use for element comparison.</param>
+    /// <returns>A <see cref="ReadOnlySpanAssertionsChain{TItem}" /> for chaining further assertions.</returns>
+    public ReadOnlySpanAssertionsChain<T> SequenceEqual([InstantHandle] IEnumerable<T> expected, IEqualityComparer<T> comparer) =>
+        SequenceEqualEnumerableCore(expected, comparer.Equals);
+
+    /// <summary>
+    /// Asserts that the span is sequence equal to the expected enumerable elements using the specified predicate.
+    /// </summary>
+    /// <param name="expected">The expected elements.</param>
+    /// <param name="predicate">The predicate to use for element comparison.</param>
+    /// <returns>A <see cref="ReadOnlySpanAssertionsChain{TItem}" /> for chaining further assertions.</returns>
+    public ReadOnlySpanAssertionsChain<T> SequenceEqual([InstantHandle] IEnumerable<T> expected, Func<T?, T?, bool> predicate) =>
+        SequenceEqualEnumerableCore(expected, predicate);
+
+    [SuppressMessage("ReSharper", "PossibleMultipleEnumeration")]
+    private ReadOnlySpanAssertionsChain<T> SequenceEqualEnumerableCore(IEnumerable<T> expected, Func<T?, T?, bool> equals)
     {
-        var equalityComparer = EqualityComparer<T>.Default;
         if (expected.TryGetCount(out var expectedCount) && Value.Length != expectedCount)
         {
             throw Verify.CreateException(
@@ -115,7 +240,7 @@ public ReadOnlySpanAssertionsChain<T> SequenceEqual([InstantHandle] IEnumerable<
                     $"Value {Format.Value(Value)} should sequence equal {Format.Enumerable(expected)} but it has more elements than the expected {expectedList.Count}.");
             }
 
-            if (!equalityComparer.Equals(actualEnumerator.Current, expectedEnumerator.Current))
+            if (!equals(actualEnumerator.Current, expectedEnumerator.Current))
             {
                 throw Verify.CreateException(
                     $"Value {Format.Value(Value, index)} should sequence equal {Format.Collection(expectedList, index, true)} but it differs at index {index}.");
@@ -138,9 +263,30 @@ public ReadOnlySpanAssertionsChain<T> SequenceEqual([InstantHandle] IEnumerable<
     /// </summary>
     /// <param name="expected">The elements the span should not be sequence equal to.</param>
     /// <returns>A <see cref="ReadOnlySpanAssertionsChain{TItem}" /> for chaining further assertions.</returns>
-    public ReadOnlySpanAssertionsChain<T> NotSequenceEqual([InstantHandle] IEnumerable<T> expected)
+    public ReadOnlySpanAssertionsChain<T> NotSequenceEqual([InstantHandle] IEnumerable<T> expected) =>
+        NotSequenceEqualEnumerableCore(expected, EqualityComparer<T>.Default.Equals);
+
+    /// <summary>
+    /// Asserts that the span is not sequence equal to the expected enumerable elements using the specified equality comparer.
+    /// </summary>
+    /// <param name="expected">The elements the span should not be sequence equal to.</param>
+    /// <param name="comparer">The equality comparer to use for element comparison.</param>
+    /// <returns>A <see cref="ReadOnlySpanAssertionsChain{TItem}" /> for chaining further assertions.</returns>
+    public ReadOnlySpanAssertionsChain<T> NotSequenceEqual([InstantHandle] IEnumerable<T> expected, IEqualityComparer<T> comparer) =>
+        NotSequenceEqualEnumerableCore(expected, comparer.Equals);
+
+    /// <summary>
+    /// Asserts that the span is not sequence equal to the expected enumerable elements using the specified predicate.
+    /// </summary>
+    /// <param name="expected">The elements the span should not be sequence equal to.</param>
+    /// <param name="predicate">The predicate to use for element comparison.</param>
+    /// <returns>A <see cref="ReadOnlySpanAssertionsChain{TItem}" /> for chaining further assertions.</returns>
+    public ReadOnlySpanAssertionsChain<T> NotSequenceEqual([InstantHandle] IEnumerable<T> expected, Func<T?, T?, bool> predicate) =>
+        NotSequenceEqualEnumerableCore(expected, predicate);
+
+    [SuppressMessage("ReSharper", "PossibleMultipleEnumeration")]
+    private ReadOnlySpanAssertionsChain<T> NotSequenceEqualEnumerableCore(IEnumerable<T> expected, Func<T?, T?, bool> equals)
     {
-        var equalityComparer = EqualityComparer<T>.Default;
         if (expected.TryGetCount(out var expectedCount) && Value.Length != expectedCount)
         {
             return new ReadOnlySpanAssertionsChain<T>(this);
@@ -170,7 +316,7 @@ public ReadOnlySpanAssertionsChain<T> NotSequenceEqual([InstantHandle] IEnumerab
                 return new ReadOnlySpanAssertionsChain<T>(this);
             }
 
-            if (!equalityComparer.Equals(actualEnumerator.Current, expectedEnumerator.Current))
+            if (!equals(actualEnumerator.Current, expectedEnumerator.Current))
             {
                 // Items not equal, not sequence equal.
                 return new ReadOnlySpanAssertionsChain<T>(this);