diff --git a/src/DynamicData.Tests/Kernal/OptionObservableFixture.cs b/src/DynamicData.Tests/Kernal/OptionObservableFixture.cs
new file mode 100644
index 000000000..06095bc20
--- /dev/null
+++ b/src/DynamicData.Tests/Kernal/OptionObservableFixture.cs
@@ -0,0 +1,286 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reactive.Linq;
+using DynamicData.Kernel;
+
+using FluentAssertions;
+
+using Xunit;
+
+namespace DynamicData.Tests.Kernal;
+
+public class OptionObservableFixture
+{
+    private const int NoneCount = 5;
+    private const int SomeCount = 10;
+
+    private static Optional<string> NotConvertableToInt { get; } = Optional.Some("NOT AN INT");
+    private static IEnumerable<int> IntEnum { get; } = Enumerable.Range(0, SomeCount);
+    private static IEnumerable<string> StringEnum { get; } = IntEnum.Select(n => n.ToString());
+    private static IEnumerable<Optional<int>> OptIntEnum { get; } = IntEnum.Select(i => Optional.Some(i));
+    private static IEnumerable<Optional<int>> OptNoneIntEnum { get; } = Enumerable.Repeat(Optional.None<int>(), NoneCount);
+    private static IEnumerable<Optional<string>> OptNoneStringEnum { get; } = Enumerable.Repeat(Optional.None<string>(), NoneCount);
+    private static IEnumerable<Optional<string>> OptStringEnum { get; } = StringEnum.Select(str => Optional.Some(str));
+    private static IEnumerable<Optional<string>> OptStringWithNoneEnum { get; } = OptNoneStringEnum.Concat(OptStringEnum);
+    private static IEnumerable<Optional<string>> OptStringWithBadEnum { get; } = OptStringEnum.Prepend(NotConvertableToInt);
+    private static IEnumerable<Optional<string>> OptStringWithBadAndNoneEnum { get; } = OptStringWithNoneEnum.Prepend(NotConvertableToInt);
+
+    [Fact]
+    public void NullChecks()
+    {
+        // having
+        var neverObservable = Observable.Never<Optional<int>>();
+        var nullObservable = (IObservable<Optional<int>>)null!;
+        var nullConverter = (Func<int, double>)null!;
+        var nullOptionalConverter = (Func<int, Optional<double>>)null!;
+        var converter = (Func<int, double>)(i => i);
+        var nullFallback = (Func<int>)null!;
+        var nullConvertFallback = (Func<double>)null!;
+        var nullOptionalFallback = (Func<Optional<int>>)null!;
+        var action = (Action)null!;
+        var actionVal = (Action<int>)null!;
+        var nullExceptionGenerator = (Func<Exception>)null!;
+
+        // when
+        var convert1 = () => nullObservable.Convert(nullConverter);
+        var convert2 = () => neverObservable.Convert(nullConverter);
+        var convertOpt1 = () => nullObservable.Convert(nullOptionalConverter);
+        var convertOpt2 = () => neverObservable.Convert(nullOptionalConverter);
+        var convertOr1 = () => nullObservable.ConvertOr(nullConverter, nullConvertFallback);
+        var convertOr2 = () => neverObservable.ConvertOr(nullConverter, nullConvertFallback);
+        var convertOr3 = () => neverObservable.ConvertOr(converter, nullConvertFallback);
+        var orElse1 = () => nullObservable.OrElse(nullOptionalFallback);
+        var orElse2 = () => neverObservable.OrElse(nullOptionalFallback);
+        var onHasValue = () => nullObservable.OnHasValue(actionVal);
+        var onHasValue2 = () => neverObservable.OnHasValue(actionVal);
+        var onHasNoValue = () => nullObservable.OnHasNoValue(action);
+        var onHasNoValue2 = () => neverObservable.OnHasNoValue(action);
+        var selectValues = () => nullObservable.SelectValues();
+        var valueOr = () => nullObservable.ValueOr(nullFallback);
+        var valueOrDefault = () => nullObservable.ValueOrDefault();
+        var valueOrThrow1 = () => nullObservable.ValueOrThrow(nullExceptionGenerator);
+        var valueOrThrow2 = () => neverObservable.ValueOrThrow(nullExceptionGenerator);
+
+        // then
+        convert1.Should().Throw<ArgumentNullException>();
+        convert2.Should().Throw<ArgumentNullException>();
+        convertOpt1.Should().Throw<ArgumentNullException>();
+        convertOpt2.Should().Throw<ArgumentNullException>();
+        convertOr1.Should().Throw<ArgumentNullException>();
+        convertOr2.Should().Throw<ArgumentNullException>();
+        convertOr3.Should().Throw<ArgumentNullException>();
+        orElse1.Should().Throw<ArgumentNullException>();
+        orElse2.Should().Throw<ArgumentNullException>();
+        onHasValue.Should().Throw<ArgumentNullException>();
+        onHasValue2.Should().Throw<ArgumentNullException>();
+        onHasNoValue.Should().Throw<ArgumentNullException>();
+        onHasNoValue2.Should().Throw<ArgumentNullException>();
+        selectValues.Should().Throw<ArgumentNullException>();
+        valueOr.Should().Throw<ArgumentNullException>();
+        valueOrDefault.Should().Throw<ArgumentNullException>();
+        valueOrThrow1.Should().Throw<ArgumentNullException>();
+        valueOrThrow2.Should().Throw<ArgumentNullException>();
+    }
+
+    [Fact]
+    public void ConvertWillConvertValues()
+    {
+        // having
+        var observable = OptStringEnum.ToObservable();
+
+        // when
+        var results = observable.Convert(ParseInt).ToEnumerable().ToList();
+        var intList = OptIntEnum.ToList();
+
+        // then
+        results.Should().BeSubsetOf(intList);
+        intList.Should().BeSubsetOf(results);
+    }
+
+    [Fact]
+    public void ConvertPreservesNone()
+    {
+        // having
+        var enumerable = OptStringWithNoneEnum;
+        var observable = enumerable.ToObservable();
+
+        // when
+        var results = observable.Convert(ParseInt).Where(opt => !opt.HasValue).ToEnumerable().Count();
+        var expected = enumerable.Where(opt => !opt.HasValue).Count();
+
+        // then
+        results.Should().Be(expected);
+        results.Should().Be(NoneCount);
+    }
+
+    [Fact]
+    public void ConvertOptionalWillConvertValues()
+    {
+        // having
+        var observable = OptStringWithBadEnum.ToObservable();
+
+        // when
+        var results = observable.Convert(ParseIntOpt).ToEnumerable().ToList();
+        var intList = OptIntEnum.ToList();
+
+        // then
+        intList.Should().BeSubsetOf(results);
+        results.Should().Contain(Optional.None<int>());
+    }
+
+    [Fact]
+    public void ConvertOptionalPreservesNone()
+    {
+        // having
+        var enumerable = OptStringWithBadAndNoneEnum;
+        var observable = enumerable.ToObservable();
+
+        // when
+        var results = observable.Convert(ParseIntOpt).Where(opt => !opt.HasValue).ToEnumerable().Count();
+        var expected = OptStringWithNoneEnum.Where(opt => !opt.HasValue).Count() + 1;
+
+        // then
+        results.Should().Be(expected);
+        results.Should().BeGreaterThan(1);
+    }
+
+    [Fact]
+    public void ConvertOrConvertsOrFallsback()
+    {
+        // having
+        var observable = OptStringWithNoneEnum.ToObservable();
+
+        // when
+        var results = observable.ConvertOr(ParseInt, () => -1).ToEnumerable();
+        var intList = IntEnum.Prepend(-1);
+
+        // then
+        results.Should().BeSubsetOf(intList);
+        intList.Should().BeSubsetOf(results);
+    }
+
+    [Fact]
+    public void OrElseFallsback()
+    {
+        // having
+        var observable = OptIntEnum.ToObservable().StartWith(Optional.None<int>());
+
+        // when
+        var results = observable.OrElse(() => -1).ToEnumerable();
+        var intList = OptIntEnum.Prepend(-1);
+
+        // then
+        results.Should().BeSubsetOf(intList);
+        intList.Should().BeSubsetOf(results);
+    }
+
+    [Fact]
+    public void OnHasValueInvokesCorrectAction()
+    {
+        // having
+        int value = 0;
+        int noValue = 0;
+        Action<int> onVal = _ => value++;
+        Action onNoVal = () => noValue++;
+        var observable = OptIntEnum.Concat(OptNoneIntEnum).ToObservable().OnHasValue(onVal, onNoVal);
+
+        // when
+        var results = observable.ToEnumerable().ToList();
+
+        // then
+        value.Should().Be(SomeCount);
+        noValue.Should().Be(NoneCount);
+    }
+
+    [Fact]
+    public void OnHasNoValueInvokesCorrectAction()
+    {
+        // having
+        int value = 0;
+        int noValue = 0;
+        Action<int> onVal = _ => value++;
+        Action onNoVal = () => noValue++;
+        var observable = OptIntEnum.Concat(OptNoneIntEnum).ToObservable().OnHasNoValue(onNoVal, onVal);
+
+        // when
+        var results = observable.ToEnumerable().ToList();
+
+        // then
+        value.Should().Be(SomeCount);
+        noValue.Should().Be(NoneCount);
+    }
+
+    [Fact]
+    public void SelectValuesReturnsTheValues()
+    {
+        // having
+        var enumerable = OptIntEnum.Concat(OptNoneIntEnum);
+        var observable = enumerable.ToObservable().SelectValues();
+
+        // when
+        var expected = enumerable.Where(opt => opt.HasValue).Count();
+        var results = observable.ToEnumerable().Count();
+
+        // then
+        expected.Should().Be(results);
+        results.Should().Be(SomeCount);
+    }
+
+    [Fact]
+    public void ValueOrInvokesSelector()
+    {
+        // having
+        int invokeCount = 0;
+        Func<int> selector = () => { invokeCount++; return -1; };
+        var enumerable = OptIntEnum.Concat(OptNoneIntEnum);
+        var observable = enumerable.ToObservable().ValueOr(selector);
+
+        // when
+        var expected = enumerable.Where(opt => !opt.HasValue).Count();
+        var results = observable.ToEnumerable().Where(i => i.Equals(-1)).Count();
+
+        // then
+        expected.Should().Be(results);
+        results.Should().Be(NoneCount);
+        invokeCount.Should().Be(NoneCount);
+    }
+
+    [Fact]
+    public void ValueOrDefaultReturnsDefaultValues()
+    {
+        // having
+        var enumerable = OptStringWithNoneEnum;
+        var observable = enumerable.ToObservable().ValueOrDefault();
+
+        // when
+        var expected = enumerable.Where(opt => !opt.HasValue).Count();
+        var results = observable.ToEnumerable().Where(str => str == default).Count();
+
+        // then
+        expected.Should().Be(results);
+        results.Should().Be(NoneCount);
+    }
+
+    [Fact]
+    public void ValueOrThrowFailsWithGeneratedError()
+    {
+        // having
+        var expectedError = new Exception("Nope");
+        var exceptionGenerator = () => expectedError;
+        var enumerable = OptStringWithNoneEnum;
+        var observable = enumerable.ToObservable().ValueOrThrow(exceptionGenerator);
+        var receivedError = default(Exception);
+
+        // when
+        using var cleanup = observable.Subscribe(_ => { }, err => receivedError = err);
+
+        // then
+        receivedError.Should().Be(expectedError);
+    }
+
+    private static Optional<int> ParseIntOpt(string input) =>
+        int.TryParse(input, out var result) ? Optional.Some(result) : Optional.None<int>();
+
+    private static int ParseInt(string input) => int.Parse(input);
+}
diff --git a/src/DynamicData/Kernel/OptionObservableExtensions.cs b/src/DynamicData/Kernel/OptionObservableExtensions.cs
new file mode 100644
index 000000000..c57ba7383
--- /dev/null
+++ b/src/DynamicData/Kernel/OptionObservableExtensions.cs
@@ -0,0 +1,271 @@
+// Copyright (c) 2011-2023 Roland Pheasant. All rights reserved.
+// Roland Pheasant licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reactive.Linq;
+
+namespace DynamicData.Kernel;
+
+/// <summary>
+/// Extensions for optional.
+/// </summary>
+public static class OptionObservableExtensions
+{
+    /// <summary>
+    /// Converts an Observable Optional of <typeparamref name="TSource"/> into an Observable Optional of <typeparamref name="TDestination"/> by applying
+    /// the conversion function to those Optionals that have a value.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the source.</typeparam>
+    /// <typeparam name="TDestination">The type of the destination.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <param name="converter">The converter.</param>
+    /// <returns>Observable Optional of <typeparamref name="TDestination"/>.</returns>
+    /// <exception cref="System.ArgumentNullException">Source or Converter was null.</exception>
+    /// <remarks>Observable version of <seealso cref="OptionExtensions.Convert{TSource, TDestination}(Optional{TSource}, Func{TSource, TDestination})"/>.</remarks>
+    public static IObservable<Optional<TDestination>> Convert<TSource, TDestination>(this IObservable<Optional<TSource>> source, Func<TSource, TDestination> converter)
+        where TSource : notnull
+        where TDestination : notnull
+    {
+        if (source is null)
+        {
+            throw new ArgumentNullException(nameof(source));
+        }
+
+        if (converter is null)
+        {
+            throw new ArgumentNullException(nameof(converter));
+        }
+
+        return source.Select(optional => optional.HasValue ? converter(optional.Value) : Optional.None<TDestination>());
+    }
+
+    /// <summary>
+    /// Overload of <see cref="Convert{TSource, TDestination}(IObservable{Optional{TSource}}, Func{TSource, TDestination})"/> that allows the conversion
+    /// operation to also return an Optional.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the source.</typeparam>
+    /// <typeparam name="TDestination">The type of the destination.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <param name="converter">The converter that returns an optional value.</param>
+    /// <returns>Observable Optional of <typeparamref name="TDestination"/>.</returns>
+    /// <exception cref="System.ArgumentNullException">Source or Converter was null.</exception>
+    /// <remarks>Observable version of <seealso cref="OptionExtensions.Convert{TSource, TDestination}(Optional{TSource}, Func{TSource, Optional{TDestination}})"/>.</remarks>
+    public static IObservable<Optional<TDestination>> Convert<TSource, TDestination>(this IObservable<Optional<TSource>> source, Func<TSource, Optional<TDestination>> converter)
+        where TSource : notnull
+        where TDestination : notnull
+    {
+        if (source is null)
+        {
+            throw new ArgumentNullException(nameof(source));
+        }
+
+        if (converter is null)
+        {
+            throw new ArgumentNullException(nameof(converter));
+        }
+
+        return source.Select(optional => optional.HasValue ? converter(optional.Value) : Optional.None<TDestination>());
+    }
+
+    /// <summary>
+    /// Converts an observable of optional into an observable of <typeparamref name="TDestination"/> by applying <paramref name="converter"/> to convert Optionals with a value
+    /// and using <paramref name="fallbackConverter"/> to generate a value for those that don't have a value.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the source.</typeparam>
+    /// <typeparam name="TDestination">The type of the destination.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <param name="converter">The converter.</param>
+    /// <param name="fallbackConverter">The fallback converter.</param>
+    /// <returns>Observable of <typeparamref name="TDestination"/>.</returns>
+    /// <exception cref="System.ArgumentNullException">
+    /// source
+    /// or
+    /// converter
+    /// or
+    /// fallbackConverter.
+    /// </exception>
+    public static IObservable<TDestination?> ConvertOr<TSource, TDestination>(this IObservable<Optional<TSource>> source, Func<TSource, TDestination?> converter, Func<TDestination?> fallbackConverter)
+        where TSource : notnull
+    {
+        if (source is null)
+        {
+            throw new ArgumentNullException(nameof(source));
+        }
+
+        if (converter is null)
+        {
+            throw new ArgumentNullException(nameof(converter));
+        }
+
+        if (fallbackConverter is null)
+        {
+            throw new ArgumentNullException(nameof(fallbackConverter));
+        }
+
+        return source.Select(optional => optional.HasValue ? converter(optional.Value) : fallbackConverter());
+    }
+
+    /// <summary>
+    /// Observable Optional operator that provides a way to (possibly) create a value for those Optionals that don't already have one.
+    /// </summary>
+    /// <typeparam name="T">The type of the source.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <param name="fallbackOperation">The fallback operation.</param>
+    /// <returns>An Observable Optional that contains the Optionals with Values or the results of the fallback operation.</returns>
+    /// <exception cref="System.ArgumentNullException">
+    /// source
+    /// or
+        /// fallbackOperation.
+        /// </exception>
+    /// <remarks>Observable version of <seealso cref="OptionExtensions.OrElse{T}(Optional{T}, Func{Optional{T}})"/>.</remarks>
+    public static IObservable<Optional<T>> OrElse<T>(this IObservable<Optional<T>> source, Func<Optional<T>> fallbackOperation)
+        where T : notnull
+    {
+        if (source is null)
+        {
+            throw new ArgumentNullException(nameof(source));
+        }
+
+        if (fallbackOperation is null)
+        {
+            throw new ArgumentNullException(nameof(fallbackOperation));
+        }
+
+        return source.Select(optional => optional.HasValue ? optional : fallbackOperation());
+    }
+
+    /// <summary>
+    /// Pass-Thru operator that invokes the specified action for Optionals with a value (or, if provided, the else Action for those without a value).
+    /// </summary>
+    /// <typeparam name="T">The type of the item.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <param name="action">The action.</param>
+    /// <param name="elseAction">Optional alternative action for the Else case.</param>
+    /// <returns>The same Observable Optional.</returns>
+    /// <remarks>Observable version of <seealso cref="OptionExtensions.IfHasValue{T}(Optional{T}, Action{T})"/>.</remarks>
+    public static IObservable<Optional<T>> OnHasValue<T>(this IObservable<Optional<T>> source, Action<T> action, Action? elseAction = null)
+        where T : notnull
+    {
+        if (source is null)
+        {
+            throw new ArgumentNullException(nameof(source));
+        }
+
+        if (action is null)
+        {
+            throw new ArgumentNullException(nameof(action));
+        }
+
+        return source.Do(optional => optional.IfHasValue(action).Else(() => elseAction?.Invoke()));
+    }
+
+    /// <summary>
+    /// Pass-Thru operator that invokes the specified action for Optionals without a value (or, if provided, the else Action for those with a value).
+    /// </summary>
+    /// <typeparam name="T">The type of the item.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <param name="action">The action.</param>
+    /// <param name="elseAction">Optional alternative action for the Else case.</param>
+    /// <returns>The same Observable Optional.</returns>
+    public static IObservable<Optional<T>> OnHasNoValue<T>(this IObservable<Optional<T>> source, Action action, Action<T>? elseAction = null)
+        where T : notnull
+    {
+        if (source is null)
+        {
+            throw new ArgumentNullException(nameof(source));
+        }
+
+        if (action is null)
+        {
+            throw new ArgumentNullException(nameof(action));
+        }
+
+        return source.Do(optional => optional.IfHasValue(val => elseAction?.Invoke(val)).Else(action));
+    }
+
+    /// <summary>
+    /// Converts an Observable of <see cref="Optional{T}"/> into an IObservable of <typeparamref name="T"/> by extracting
+    /// the values from Optionals that have one.
+    /// </summary>
+    /// <typeparam name="T">The type of item.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <returns>An Observable with the Values.</returns>
+    /// <remarks>Observable version of <seealso cref="OptionExtensions.SelectValues{T}(IEnumerable{Optional{T}})"/>.</remarks>
+    public static IObservable<T> SelectValues<T>(this IObservable<Optional<T>> source)
+        where T : notnull
+    {
+        return source.Where(t => t.HasValue && t.Value is not null).Select(t => t.Value!);
+    }
+
+    /// <summary>
+    /// Converts an Observable of <see cref="Optional{T}"/> into an IObservable of <typeparamref name="T"/> by extracting the
+    /// values from the ones that contain a value and then using <paramref name="valueSelector"/> to generate a value for the others.
+    /// </summary>
+    /// <typeparam name="T">The type of the item.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <param name="valueSelector">The value selector.</param>
+    /// <returns>If the value or a provided default.</returns>
+    /// <exception cref="System.ArgumentNullException">valueSelector.</exception>
+    /// <remarks>Observable version of <seealso cref="OptionExtensions.ValueOr{T}(Optional{T}, Func{T})"/>.</remarks>
+    public static IObservable<T> ValueOr<T>(this IObservable<Optional<T>> source, Func<T> valueSelector)
+        where T : notnull
+    {
+        if (source is null)
+        {
+            throw new ArgumentNullException(nameof(source));
+        }
+
+        return source.Select(optional => optional.HasValue ? optional.Value : valueSelector());
+    }
+
+    /// <summary>
+    /// Returns the value if the optional has a value, otherwise returns the default value of T.
+    /// </summary>
+    /// <typeparam name="T">The type of the item.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <returns>The value or default.</returns>
+    /// <remarks>Observable version of <seealso cref="OptionExtensions.ValueOrDefault{T}(Optional{T})"/>.</remarks>
+    public static IObservable<T?> ValueOrDefault<T>(this IObservable<Optional<T>> source)
+        where T : notnull
+    {
+        if (source is null)
+        {
+            throw new ArgumentNullException(nameof(source));
+        }
+
+        return source.Select(optional => optional.ValueOrDefault());
+    }
+
+    /// <summary>
+    /// Converts an Observable of <see cref="Optional{T}"/> into an IObservable of <typeparamref name="T"/> by extracting the values.
+    /// If it has no value, <paramref name="exceptionGenerator"/> is used to generate an exception that is injected into the stream as error.
+    /// </summary>
+    /// <typeparam name="T">The type of the item.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <param name="exceptionGenerator">The exception generator.</param>
+    /// <returns>The value.</returns>
+    /// <exception cref="System.ArgumentNullException">exceptionGenerator.</exception>
+    /// <remarks>Observable version of <seealso cref="OptionExtensions.ValueOrThrow{T}(Optional{T}, Func{Exception})"/>.</remarks>
+    public static IObservable<T> ValueOrThrow<T>(this IObservable<Optional<T>> source, Func<Exception> exceptionGenerator)
+        where T : notnull
+    {
+        if (source is null)
+        {
+            throw new ArgumentNullException(nameof(source));
+        }
+
+        if (exceptionGenerator is null)
+        {
+            throw new ArgumentNullException(nameof(exceptionGenerator));
+        }
+
+        return Observable.Create<T>(observer =>
+            source.Subscribe(
+                optional => optional.IfHasValue(val => observer.OnNext(val)).Else(() => observer.OnError(exceptionGenerator())),
+                observer.OnError,
+                observer.OnCompleted));
+    }
+}