diff --git a/src/Umbraco.StorageProviders/Abstractions/IStorageProvider.cs b/src/Umbraco.StorageProviders/Abstractions/IStorageProvider.cs
new file mode 100644
index 0000000..302b51c
--- /dev/null
+++ b/src/Umbraco.StorageProviders/Abstractions/IStorageProvider.cs
@@ -0,0 +1,91 @@
+using Microsoft.Extensions.FileProviders;
+
+namespace Umbraco.StorageProviders;
+
+/// <summary>
+/// A read/write storage provider abstraction.
+/// </summary>
+/// <seealso cref="Microsoft.Extensions.FileProviders.IFileProvider" />
+public interface IStorageProvider : IFileProvider
+{
+    /// <summary>
+    /// Create a writable stream to store file contents. Caller should dispose the stream when complete.
+    /// </summary>
+    /// <param name="subpath">The path/name of the file.</param>
+    /// <param name="overwrite"><c>true</c> if the file can be overwritten; otherwise, <c>false</c>.</param>
+    /// <returns>
+    /// The file stream.
+    /// </returns>
+    Stream? CreateWriteStream(string subpath, bool overwrite = false);
+
+    /// <summary>
+    /// Moves the specified file to a new location, providing the option to specify a new file name.
+    /// </summary>
+    /// <param name="sourceSubpath">The path/name of the source file.</param>
+    /// <param name="destinationSubpath">The path/name of the destination file. This cannot be a directory.</param>
+    /// <param name="overwrite"><c>true</c> if the destination file can be overwritten; otherwise, <c>false</c>.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>
+    /// Returns a value indicating whether the operation succeeded.
+    /// </returns>
+    Task<bool> MoveAsync(string sourceSubpath, string destinationSubpath, bool overwrite = false, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Moves the specified directory to a new location.
+    /// </summary>
+    /// <param name="sourceSubpath">The path/name of the source directory.</param>
+    /// <param name="destinationSubpath">The path/name of the destination directory.</param>
+    /// <param name="overwrite"><c>true</c> if files in the destination directory can be overwritten; otherwise, <c>false</c>.</param>
+    /// <param name="recursive"><c>true</c> to recursively move subdirectories and files; otherwise, <c>false</c>.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>
+    /// Returns a value indicating whether the operation succeeded.
+    /// </returns>
+    Task<bool> MoveDirectoryAsync(string sourceSubpath, string destinationSubpath, bool overwrite = false, bool recursive = false, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Copies an existing file to a new file, providing the option to specify a new file name.
+    /// </summary>
+    /// <param name="sourceSubpath">The path/name of the source directory.</param>
+    /// <param name="destinationSubpath">The path/name of the destination file. This cannot be a directory.</param>
+    /// <param name="overwrite"><c>true</c> if the destination file can be overwritten; otherwise, <c>false</c>.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>
+    /// Returns a value indicating whether the operation succeeded.
+    /// </returns>
+    Task<bool> CopyAsync(string sourceSubpath, string destinationSubpath, bool overwrite = false, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Copies an existing directory to a new directory.
+    /// </summary>
+    /// <param name="sourceSubpath">The path/name of the source directory.</param>
+    /// <param name="destinationSubpath">The path/name of the destination directory.</param>
+    /// <param name="overwrite"><c>true</c> if files in the destination directory can be overwritten; otherwise, <c>false</c>.</param>
+    /// <param name="recursive"><c>true</c> to recursively copy subdirectories and files; otherwise, <c>false</c>.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>
+    /// Returns a value indicating whether the operation succeeded.
+    /// </returns>
+    Task<bool> CopyDirectoryAsync(string sourceSubpath, string destinationSubpath, bool overwrite = false, bool recursive = false, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Deletes the specified file.
+    /// </summary>
+    /// <param name="subpath">The path/name of the file.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>
+    /// Returns a value indicating whether the operation succeeded.
+    /// </returns>
+    Task<bool> DeleteAsync(string subpath, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Deletes the specified directory.
+    /// </summary>
+    /// <param name="subpath">The path/name of the directory.</param>
+    /// <param name="recursive"><c>true</c> to recursively remove subdirectories and files; otherwise, <c>false</c>.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>
+    /// Returns a value indicating whether the operation succeeded.
+    /// </returns>
+    Task<bool> DeleteDirectoryAsync(string subpath, bool recursive = false, CancellationToken cancellationToken = default);
+}
diff --git a/src/Umbraco.StorageProviders/Abstractions/StorageProviderBase.cs b/src/Umbraco.StorageProviders/Abstractions/StorageProviderBase.cs
new file mode 100644
index 0000000..363b27c
--- /dev/null
+++ b/src/Umbraco.StorageProviders/Abstractions/StorageProviderBase.cs
@@ -0,0 +1,146 @@
+using Microsoft.Extensions.FileProviders;
+using Microsoft.Extensions.Primitives;
+
+namespace Umbraco.StorageProviders;
+
+/// <summary>
+/// Provides a generic implementation for most storage provider actions.
+/// </summary>
+/// <remarks>
+/// The default implementation where moving is based on copy/delete and copying requires reading/writing the file contents.
+/// </remarks>
+/// <seealso cref="Umbraco.StorageProviders.IStorageProvider" />
+public abstract class StorageProviderBase : IStorageProvider
+{
+    /// <inheritdoc />
+    public abstract IDirectoryContents GetDirectoryContents(string subpath);
+
+    /// <inheritdoc />
+    public abstract IFileInfo GetFileInfo(string subpath);
+
+    /// <inheritdoc />
+    public virtual IChangeToken Watch(string filter) => NullChangeToken.Singleton;
+
+    /// <inheritdoc />
+    public abstract Stream CreateWriteStream(string subpath, bool overwrite = false);
+
+    /// <inheritdoc />
+    public virtual async Task<bool> MoveAsync(string sourceSubpath, string destinationSubpath, bool overwrite = false, CancellationToken cancellationToken = default)
+        => await CopyAsync(sourceSubpath, destinationSubpath, overwrite, cancellationToken).ConfigureAwait(false) &&
+            await DeleteAsync(sourceSubpath, cancellationToken).ConfigureAwait(false);
+
+    /// <inheritdoc />
+    public virtual async Task<bool> MoveDirectoryAsync(string sourceSubpath, string destinationSubpath, bool overwrite = false, bool recursive = false, CancellationToken cancellationToken = default)
+    {
+        var sourceDirectoryContents = GetDirectoryContents(sourceSubpath);
+        if (sourceDirectoryContents is null || sourceDirectoryContents.Exists is false)
+        {
+            return false;
+        }
+
+        foreach (var sourceFileInfo in sourceDirectoryContents)
+        {
+            var sourcePath = CombinePath(sourceSubpath, sourceFileInfo.Name);
+            var destinationPath = CombinePath(destinationSubpath, sourceFileInfo.Name);
+
+            if (sourceFileInfo.IsDirectory is false)
+            {
+                await MoveAsync(sourcePath, destinationPath, overwrite, cancellationToken).ConfigureAwait(false);
+            }
+            else if (recursive)
+            {
+                await MoveDirectoryAsync(sourcePath, destinationPath, overwrite, recursive, cancellationToken).ConfigureAwait(false);
+            }
+        }
+
+        return true;
+    }
+
+    /// <inheritdoc />
+    public virtual async Task<bool> CopyAsync(string sourceSubpath, string destinationSubpath, bool overwrite = false, CancellationToken cancellationToken = default)
+        => await CopyAsync(GetFileInfo(sourceSubpath), destinationSubpath, overwrite, cancellationToken).ConfigureAwait(false);
+
+    /// <inheritdoc />
+    protected virtual async Task<bool> CopyAsync(IFileInfo sourceFileInfo, string destinationSubpath, bool overwrite = false, CancellationToken cancellationToken = default)
+    {
+        if (sourceFileInfo is null || sourceFileInfo.Exists is false || sourceFileInfo.IsDirectory)
+        {
+            return false;
+        }
+
+        using (var source = sourceFileInfo.CreateReadStream())
+        using (var destination = CreateWriteStream(destinationSubpath, overwrite))
+        {
+            await source.CopyToAsync(destination, cancellationToken).ConfigureAwait(false);
+        }
+
+        return true;
+    }
+
+    /// <inheritdoc />
+    public virtual async Task<bool> CopyDirectoryAsync(string sourceSubpath, string destinationSubpath, bool overwrite = false, bool recursive = false, CancellationToken cancellationToken = default)
+    {
+        var sourceDirectoryContents = GetDirectoryContents(sourceSubpath);
+        if (sourceDirectoryContents is null || sourceDirectoryContents.Exists is false)
+        {
+            return false;
+        }
+
+        foreach (var sourceFileInfo in sourceDirectoryContents)
+        {
+            var destinationPath = CombinePath(destinationSubpath, sourceFileInfo.Name);
+
+            if (sourceFileInfo.IsDirectory is false)
+            {
+                await CopyAsync(sourceFileInfo, destinationPath, overwrite, cancellationToken).ConfigureAwait(false);
+            }
+            else if (recursive)
+            {
+                var sourcePath = CombinePath(sourceSubpath, sourceFileInfo.Name);
+
+                await CopyDirectoryAsync(sourcePath, destinationPath, overwrite, recursive, cancellationToken).ConfigureAwait(false);
+            }
+        }
+
+        return true;
+    }
+
+    /// <inheritdoc />
+    public abstract Task<bool> DeleteAsync(string subpath, CancellationToken cancellationToken = default);
+
+    /// <inheritdoc />
+    public virtual async Task<bool> DeleteDirectoryAsync(string subpath, bool recursive = false, CancellationToken cancellationToken = default)
+    {
+        var directoryContents = GetDirectoryContents(subpath);
+        if (directoryContents is null || directoryContents.Exists is false)
+        {
+            return false;
+        }
+
+        foreach (var fileInfo in directoryContents)
+        {
+            var path = CombinePath(subpath, fileInfo.Name);
+
+            if (fileInfo.IsDirectory is false)
+            {
+                await DeleteAsync(path, cancellationToken).ConfigureAwait(false);
+            }
+            else if (recursive)
+            {
+                await DeleteDirectoryAsync(path, recursive, cancellationToken).ConfigureAwait(false);
+            }
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    /// Combines the path and file name.
+    /// </summary>
+    /// <param name="path">The path.</param>
+    /// <param name="fileName">The file name.</param>
+    /// <returns>
+    /// The combined path and file name.
+    /// </returns>
+    protected virtual string CombinePath(string path, string fileName) => Path.Combine(path, fileName);
+}
diff --git a/src/Umbraco.StorageProviders/FileSystem/FileSystemDirectoryContents.cs b/src/Umbraco.StorageProviders/FileSystem/FileSystemDirectoryContents.cs
new file mode 100644
index 0000000..3997f6e
--- /dev/null
+++ b/src/Umbraco.StorageProviders/FileSystem/FileSystemDirectoryContents.cs
@@ -0,0 +1,56 @@
+using System.Collections;
+using Microsoft.Extensions.FileProviders;
+using Umbraco.Cms.Core.IO;
+
+namespace Umbraco.StorageProviders.FileSystem;
+
+/// <summary>
+/// Represents the directory contents in an <see cref="IFileSystem" />.
+/// </summary>
+/// <seealso cref="Microsoft.Extensions.FileProviders.IDirectoryContents" />
+public class FileSystemDirectoryContents : IDirectoryContents
+{
+    private readonly IFileSystem _fileSystem;
+    private readonly string _subpath;
+    private IEnumerable<IFileInfo> _entries = null!;
+
+    /// <inheritdoc />
+    public bool Exists => true;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="FileSystemDirectoryContents"/> class.
+    /// </summary>
+    /// <param name="fileSystem">The file system.</param>
+    /// <param name="subpath">The subpath.</param>
+    /// <exception cref="System.ArgumentNullException">
+    /// fileSystem
+    /// or
+    /// subpath
+    /// </exception>
+    public FileSystemDirectoryContents(IFileSystem fileSystem, string subpath)
+    {
+        _fileSystem = fileSystem ?? throw new ArgumentNullException(nameof(fileSystem));
+        _subpath = subpath ?? throw new ArgumentNullException(nameof(subpath));
+    }
+
+    /// <inheritdoc />
+    public IEnumerator<IFileInfo> GetEnumerator()
+    {
+        EnsureInitialized();
+        return _entries.GetEnumerator();
+    }
+
+    /// <inheritdoc />
+    IEnumerator IEnumerable.GetEnumerator()
+    {
+        EnsureInitialized();
+        return _entries.GetEnumerator();
+    }
+
+    private void EnsureInitialized()
+    {
+        _entries = _fileSystem.GetDirectories(_subpath).Select<string, IFileInfo>(d => new FileSystemDirectoryInfo(_fileSystem, d))
+            .Union(_fileSystem.GetFiles(_subpath).Select<string, IFileInfo>(f => new FileSystemFileInfo(_fileSystem, f)))
+            .ToList();
+    }
+}
diff --git a/src/Umbraco.StorageProviders/FileSystem/FileSystemDirectoryInfo.cs b/src/Umbraco.StorageProviders/FileSystem/FileSystemDirectoryInfo.cs
new file mode 100644
index 0000000..289cbee
--- /dev/null
+++ b/src/Umbraco.StorageProviders/FileSystem/FileSystemDirectoryInfo.cs
@@ -0,0 +1,46 @@
+using Microsoft.Extensions.FileProviders;
+using Umbraco.Cms.Core.IO;
+
+namespace Umbraco.StorageProviders.FileSystem;
+
+/// <summary>
+/// Represents a directory in an <see cref="IFileSystem" />.
+/// </summary>
+/// <seealso cref="Microsoft.Extensions.FileProviders.IFileInfo" />
+public class FileSystemDirectoryInfo : IFileInfo
+{
+    private readonly IFileSystem _fileSystem;
+    private readonly string _subpath;
+
+    /// <inheritdoc />
+    public bool Exists => true;
+
+    /// <inheritdoc />
+    public bool IsDirectory => true;
+
+    /// <inheritdoc />
+    public DateTimeOffset LastModified => _fileSystem.GetLastModified(_subpath);
+
+    /// <inheritdoc />
+    public long Length => -1;
+
+    /// <inheritdoc />
+    public string Name => _fileSystem.GetRelativePath(_subpath);
+
+    /// <inheritdoc />
+    public string PhysicalPath => null!;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="FileSystemDirectoryInfo" /> class.
+    /// </summary>
+    /// <param name="fileSystem">The file system.</param>
+    /// <param name="subpath">The subpath.</param>
+    public FileSystemDirectoryInfo(IFileSystem fileSystem, string subpath)
+    {
+        _fileSystem = fileSystem ?? throw new ArgumentNullException(nameof(fileSystem));
+        _subpath = subpath ?? throw new ArgumentNullException(nameof(subpath));
+    }
+
+    /// <inheritdoc />
+    public Stream CreateReadStream() => throw new InvalidOperationException("Cannot create a stream for a directory.");
+}
diff --git a/src/Umbraco.StorageProviders/FileSystem/FileSystemFileInfo.cs b/src/Umbraco.StorageProviders/FileSystem/FileSystemFileInfo.cs
new file mode 100644
index 0000000..cbd5dfb
--- /dev/null
+++ b/src/Umbraco.StorageProviders/FileSystem/FileSystemFileInfo.cs
@@ -0,0 +1,46 @@
+using Microsoft.Extensions.FileProviders;
+using Umbraco.Cms.Core.IO;
+
+namespace Umbraco.StorageProviders.FileSystem;
+
+/// <summary>
+/// Represents a file in an <see cref="IFileSystem" />.
+/// </summary>
+/// <seealso cref="Microsoft.Extensions.FileProviders.IFileInfo" />
+public class FileSystemFileInfo : IFileInfo
+{
+    private readonly IFileSystem _fileSystem;
+    private readonly string _subpath;
+
+    /// <inheritdoc />
+    public bool Exists => true;
+
+    /// <inheritdoc />
+    public bool IsDirectory => false;
+
+    /// <inheritdoc />
+    public DateTimeOffset LastModified => _fileSystem.GetLastModified(_subpath);
+
+    /// <inheritdoc />
+    public long Length => _fileSystem.GetSize(_subpath);
+
+    /// <inheritdoc />
+    public string Name => _fileSystem.GetRelativePath(_subpath);
+
+    /// <inheritdoc />
+    public string PhysicalPath => null!;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="FileSystemFileInfo" /> class.
+    /// </summary>
+    /// <param name="fileSystem">The file system.</param>
+    /// <param name="subpath">The subpath.</param>
+    public FileSystemFileInfo(IFileSystem fileSystem, string subpath)
+    {
+        _fileSystem = fileSystem ?? throw new ArgumentNullException(nameof(fileSystem));
+        _subpath = subpath ?? throw new ArgumentNullException(nameof(subpath));
+    }
+
+    /// <inheritdoc />
+    public Stream CreateReadStream() => _fileSystem.OpenFile(_subpath);
+}
diff --git a/src/Umbraco.StorageProviders/FileSystem/FileSystemFileProvider.cs b/src/Umbraco.StorageProviders/FileSystem/FileSystemFileProvider.cs
new file mode 100644
index 0000000..9809db6
--- /dev/null
+++ b/src/Umbraco.StorageProviders/FileSystem/FileSystemFileProvider.cs
@@ -0,0 +1,62 @@
+using Microsoft.Extensions.FileProviders;
+using Microsoft.Extensions.Primitives;
+using Umbraco.Cms.Core.IO;
+using Umbraco.StorageProviders.FileSystem;
+
+namespace Umbraco.StorageProviders;
+
+/// <summary>
+/// Exposes an <see cref="IFileSystem" /> as an <see cref="IFileProvider" />.
+/// </summary>
+/// <seealso cref="Microsoft.Extensions.FileProviders.IFileProvider" />
+public class FileSystemFileProvider : IFileProvider
+{
+    /// <summary>
+    /// The file system.
+    /// </summary>
+    protected IFileSystem FileSystem { get; }
+
+    /// <summary>
+    /// The path prefix.
+    /// </summary>
+    protected string? PathPrefix { get; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="FileSystemFileProvider" /> class.
+    /// </summary>
+    /// <param name="fileSystem">The file system.</param>
+    /// <param name="pathPrefix">The path prefix.</param>
+    /// <exception cref="System.ArgumentNullException">fileSystem</exception>
+    public FileSystemFileProvider(IFileSystem fileSystem, string? pathPrefix = null)
+    {
+        FileSystem = fileSystem ?? throw new ArgumentNullException(nameof(fileSystem));
+        PathPrefix = pathPrefix;
+    }
+
+    /// <inheritdoc />
+    public IDirectoryContents GetDirectoryContents(string subpath)
+    {
+        var path = PathPrefix + subpath;
+        if (path == null || !FileSystem.DirectoryExists(path))
+        {
+            return NotFoundDirectoryContents.Singleton;
+        }
+
+        return new FileSystemDirectoryContents(FileSystem, path);
+    }
+
+    /// <inheritdoc />
+    public IFileInfo GetFileInfo(string subpath)
+    {
+        var path = PathPrefix + subpath;
+        if (!FileSystem.FileExists(path))
+        {
+            return new NotFoundFileInfo(path);
+        }
+
+        return new FileSystemFileInfo(FileSystem, path);
+    }
+
+    /// <inheritdoc />
+    public IChangeToken Watch(string filter) => NullChangeToken.Singleton;
+}
diff --git a/src/Umbraco.StorageProviders/FileSystem/FileSystemStorageProvider.cs b/src/Umbraco.StorageProviders/FileSystem/FileSystemStorageProvider.cs
new file mode 100644
index 0000000..5a52974
--- /dev/null
+++ b/src/Umbraco.StorageProviders/FileSystem/FileSystemStorageProvider.cs
@@ -0,0 +1,90 @@
+using Umbraco.Cms.Core.IO;
+
+namespace Umbraco.StorageProviders;
+
+/// <summary>
+/// Exposes an <see cref="IFileSystem" /> as an <see cref="IStorageProvider" />.
+/// </summary>
+/// <seealso cref="Umbraco.StorageProviders.FileSystemFileProvider" />
+/// <seealso cref="Umbraco.StorageProviders.IStorageProvider" />
+public class FileSystemStorageProvider : FileSystemFileProvider, IStorageProvider
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="FileSystemStorageProvider" /> class.
+    /// </summary>
+    /// <param name="fileSystem">The file system.</param>
+    /// <param name="pathPrefix">The path prefix.</param>
+    public FileSystemStorageProvider(IFileSystem fileSystem, string? pathPrefix = null)
+        : base(fileSystem, pathPrefix)
+    { }
+
+    ///// <inheritdoc />
+    //public void CopyFile(string sourceSubpath, string destinationSubpath, bool overwrite = false)
+    //{
+    //    var sourcePath = PathPrefix + sourceSubpath;
+    //    var destinationPath = PathPrefix + destinationSubpath;
+    //    if (sourcePath != null && destinationPath != null)
+    //    {
+    //        using var stream = FileSystem.OpenFile(sourcePath);
+    //        FileSystem.AddFile(destinationPath, stream, overwrite);
+    //    }
+    //}
+
+    ///// <inheritdoc />
+    //public void DeleteDirectory(string subpath, bool recursive = false)
+    //{
+    //    var path = PathPrefix + subpath;
+    //    if (path != null)
+    //    {
+    //        FileSystem.DeleteDirectory(path, recursive);
+    //    }
+    //}
+
+    ///// <inheritdoc />
+    //public void DeleteFile(string subpath)
+    //{
+    //    var path = PathPrefix + subpath;
+    //    if (path != null)
+    //    {
+    //        FileSystem.DeleteFile(path);
+    //    }
+    //}
+
+    ///// <inheritdoc />
+    //public void MoveFile(string sourceSubpath, string destinationSubpath, bool overwrite = false)
+    //{
+    //    CopyFile(sourceSubpath, destinationSubpath, overwrite);
+    //    DeleteFile(sourceSubpath);
+    //}
+
+    ///// <inheritdoc />
+    //public void StoreFile(string subpath, Stream stream, bool overwrite = false)
+    //{
+    //    var path = PathPrefix + subpath;
+    //    if (path != null)
+    //    {
+    //        FileSystem.AddFile(path, stream, overwrite);
+    //    }
+    //}
+
+    /// <inheritdoc />
+    public Stream? CreateWriteStream(string subpath, bool overwrite = false) => throw new NotImplementedException();
+
+    /// <inheritdoc />
+    public Task<bool> MoveAsync(string sourceSubpath, string destinationSubpath, bool overwrite = false, CancellationToken cancellationToken = default) => throw new NotImplementedException();
+
+    /// <inheritdoc />
+    public Task<bool> MoveDirectoryAsync(string sourceSubpath, string destinationSubpath, bool overwrite = false, bool recursive = false, CancellationToken cancellationToken = default) => throw new NotImplementedException();
+
+    /// <inheritdoc />
+    public Task<bool> CopyAsync(string sourceSubpath, string destinationSubpath, bool overwrite = false, CancellationToken cancellationToken = default) => throw new NotImplementedException();
+
+    /// <inheritdoc />
+    public Task<bool> CopyDirectoryAsync(string sourceSubpath, string destinationSubpath, bool overwrite = false, bool recursive = false, CancellationToken cancellationToken = default) => throw new NotImplementedException();
+
+    /// <inheritdoc />
+    public Task<bool> DeleteAsync(string subpath, CancellationToken cancellationToken = default) => throw new NotImplementedException();
+
+    /// <inheritdoc />
+    public Task<bool> DeleteDirectoryAsync(string subpath, bool recursive = false, CancellationToken cancellationToken = default) => throw new NotImplementedException();
+}
diff --git a/src/Umbraco.StorageProviders/Internal/PathUtils.cs b/src/Umbraco.StorageProviders/Internal/PathUtils.cs
new file mode 100644
index 0000000..07d8e43
--- /dev/null
+++ b/src/Umbraco.StorageProviders/Internal/PathUtils.cs
@@ -0,0 +1,49 @@
+using Microsoft.Extensions.Primitives;
+
+namespace Umbraco.StorageProviders.Internal;
+
+internal static class PathUtils
+{
+    private static readonly char[] _invalidFileNameChars = Path.GetInvalidFileNameChars()
+        .Where(c => c != Path.DirectorySeparatorChar && c != Path.AltDirectorySeparatorChar).ToArray();
+
+    private static readonly char[] _pathSeparators = new[]
+    {
+        Path.DirectorySeparatorChar,
+        Path.AltDirectorySeparatorChar
+    };
+
+    internal static bool HasInvalidPathChars(string path)
+    {
+        return path.IndexOfAny(_invalidFileNameChars) != -1;
+    }
+
+    internal static bool PathNavigatesAboveRoot(string path)
+    {
+        var tokenizer = new StringTokenizer(path, _pathSeparators);
+        int depth = 0;
+
+        foreach (StringSegment segment in tokenizer)
+        {
+            if (segment.Equals(".") || segment.Equals(""))
+            {
+                continue;
+            }
+            else if (segment.Equals(".."))
+            {
+                depth--;
+
+                if (depth == -1)
+                {
+                    return true;
+                }
+            }
+            else
+            {
+                depth++;
+            }
+        }
+
+        return false;
+    }
+}
diff --git a/src/Umbraco.StorageProviders/Physical/PhysicalStorageProvider.cs b/src/Umbraco.StorageProviders/Physical/PhysicalStorageProvider.cs
new file mode 100644
index 0000000..38e10ba
--- /dev/null
+++ b/src/Umbraco.StorageProviders/Physical/PhysicalStorageProvider.cs
@@ -0,0 +1,440 @@
+using Microsoft.Extensions.FileProviders;
+using Microsoft.Extensions.FileProviders.Physical;
+using Umbraco.StorageProviders.Internal;
+
+namespace Umbraco.StorageProviders;
+
+/// <summary>
+/// Storage provider for the on-disk file system.
+/// </summary>
+/// <seealso cref="Umbraco.StorageProviders.IStorageProvider" />
+/// <seealso cref="Microsoft.Extensions.FileProviders.PhysicalFileProvider" />
+public class PhysicalStorageProvider : PhysicalFileProvider, IStorageProvider
+{
+    private static readonly char[] _pathSeparators = new[]
+    {
+        Path.DirectorySeparatorChar,
+        Path.AltDirectorySeparatorChar
+    };
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="PhysicalStorageProvider" /> class.
+    /// </summary>
+    /// <param name="root">The root directory. This should be an absolute path.</param>
+    public PhysicalStorageProvider(string root)
+        : base(root)
+    { }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="PhysicalStorageProvider" /> class.
+    /// </summary>
+    /// <param name="root">The root directory. This should be an absolute path.</param>
+    /// <param name="filters">Specifies which files or directories are excluded.</param>
+    public PhysicalStorageProvider(string root, ExclusionFilters filters)
+        : base(root, filters)
+    { }
+
+    /// <inheritdoc />
+    public Stream? CreateWriteStream(string subpath, bool overwrite = false)
+    {
+        if (TryGetFullPath(subpath, out string fullPath))
+        {
+            EnsureDirectory(fullPath);
+
+            return File.Open(fullPath, overwrite ? FileMode.Create : FileMode.CreateNew, FileAccess.Write, FileShare.None);
+        }
+
+        return null;
+    }
+
+    /// <inheritdoc />
+    public Task<bool> MoveAsync(string sourceSubpath, string destinationSubpath, bool overwrite = false, CancellationToken cancellationToken = default)
+    {
+        var fileInfo = GetFileInfo(sourceSubpath);
+        if (fileInfo.Exists &&
+            fileInfo.PhysicalPath is string sourceFullPath &&
+            TryGetFullPath(destinationSubpath, out string destinationFullPath))
+        {
+            EnsureDirectory(destinationFullPath);
+
+            File.Move(sourceFullPath, destinationFullPath, overwrite);
+
+            return Task.FromResult(true);
+        }
+
+        return Task.FromResult(false);
+    }
+
+    /// <inheritdoc />
+    public Task<bool> MoveDirectoryAsync(string sourceSubpath, string destinationSubpath, bool overwrite = false, bool recursive = false, CancellationToken cancellationToken = default)
+    {
+        var directoryContents = GetDirectoryContents(sourceSubpath);
+        if (directoryContents.Exists &&
+            TryGetFullPath(sourceSubpath, out string sourceFullPath) &&
+            TryGetFullPath(destinationSubpath, out string destinationFullPath))
+        {
+            EnsureDirectory(destinationFullPath);
+
+            bool deleteSourceDirectory = true;
+            foreach (var fileInfo in directoryContents)
+            {
+                if (fileInfo.PhysicalPath is string sourceFilePath)
+                {
+                    var relativeSourcePath = Path.GetRelativePath(sourceFullPath, sourceFilePath);
+                    var destinationFilePath = Path.Combine(destinationFullPath, relativeSourcePath);
+
+                    if (!fileInfo.IsDirectory)
+                    {
+                        File.Move(sourceFilePath, destinationFilePath, overwrite);
+                    }
+                    else if (recursive)
+                    {
+                        MoveDirectoryAsync(sourceFilePath, destinationFilePath);
+                    }
+                    else
+                    {
+                        // We have subdirectories, but aren't recursively moving them, so can't delete source directory
+                        deleteSourceDirectory = false;
+                    }
+                }
+
+
+            }
+
+            var directoryInfo = new DirectoryInfo(sourceFullPath);
+            if (directoryInfo.Exists)
+            {
+                EnsureDirectory(destinationSubpath);
+
+                // Move files
+                foreach (var fileInfo in directoryInfo.EnumerateFiles())
+                {
+                    var destinationFilePath = Path.Combine(destinationFullPath, Path.GetRelativePath(sourceFullPath, fileInfo.FullName));
+
+                    fileInfo.MoveTo(destinationFilePath, overwrite);
+                }
+
+                if (recursive)
+                {
+                    foreach (var subDirectoryInfo in directoryInfo.EnumerateDirectories())
+                    {
+
+                    }
+                }
+
+                return Task.FromResult(true);
+            }
+        }
+
+        return Task.FromResult(false);
+    }
+
+    /// <inheritdoc />
+    public Task<bool> CopyAsync(string sourceSubpath, string destinationSubpath, bool overwrite = false, CancellationToken cancellationToken = default)
+    {
+        if (TryGetFullPath(sourceSubpath, out string sourceFullPath) &&
+            TryGetFullPath(destinationSubpath, out string destinationFullPath))
+        {
+            var fileInfo = new FileInfo(sourceFullPath);
+            if (fileInfo.Exists)
+            {
+                EnsureDirectory(destinationSubpath);
+
+                fileInfo.CopyTo(destinationFullPath, overwrite);
+
+                return Task.FromResult(true);
+            }
+        }
+
+        return Task.FromResult(false);
+    }
+
+    /// <inheritdoc />
+    public Task<bool> CopyDirectoryAsync(string sourceSubpath, string destinationSubpath, bool overwrite = false, bool recursive = false, CancellationToken cancellationToken = default)
+    {
+        if (TryGetFullPath(sourceSubpath, out string sourceFullPath) &&
+            TryGetFullPath(destinationSubpath, out string destinationFullPath))
+        {
+            var directoryInfo = new DirectoryInfo(sourceFullPath);
+            if (directoryInfo.Exists)
+            {
+                
+
+                return Task.FromResult(true);
+            }
+        }
+
+        return Task.FromResult(false);
+    }
+
+    /// <inheritdoc />
+    public Task<bool> DeleteAsync(string subpath, CancellationToken cancellationToken = default)
+    {
+        if (TryGetFullPath(subpath, out string fullPath))
+        {
+            var fileInfo = new FileInfo(subpath);
+            if (fileInfo.Exists)
+            {
+                fileInfo.Delete();
+
+                return Task.FromResult(true);
+            }
+        }
+
+        return Task.FromResult(false);
+    }
+
+    /// <inheritdoc />
+    public Task<bool> DeleteDirectoryAsync(string subpath, bool recursive = false, CancellationToken cancellationToken = default)
+    {
+        if (TryGetFullPath(subpath, out string fullPath))
+        {
+            var directoryInfo = new DirectoryInfo(subpath);
+            if (directoryInfo.Exists)
+            {
+                directoryInfo.Delete(recursive);
+
+                return Task.FromResult(true);
+            }
+        }
+
+        return Task.FromResult(false);
+    }
+
+    private bool TryGetFullPath(string subpath, out string fullPath)
+    {
+        if (string.IsNullOrEmpty(subpath) || PathUtils.HasInvalidPathChars(subpath))
+        {
+            fullPath = null!;
+            return false;
+        }
+
+        // Relative paths starting with leading slashes are okay
+        subpath = subpath.TrimStart(_pathSeparators);
+
+        // Absolute paths not permitted
+        if (Path.IsPathRooted(subpath))
+        {
+            fullPath = null!;
+            return false;
+        }
+
+        if (PathUtils.PathNavigatesAboveRoot(subpath))
+        {
+            fullPath = null!;
+            return false;
+        }
+
+        try
+        {
+            fullPath = Path.GetFullPath(Path.Combine(Root, subpath));
+        }
+        catch
+        {
+            fullPath = null!;
+            return false;
+        }
+
+        if (!fullPath.StartsWith(Root, StringComparison.OrdinalIgnoreCase))
+        {
+            return false;
+        }
+
+        return true;
+    }
+
+    private static void EnsureDirectory(string fullPath)
+    {
+        var directoryName = Path.GetDirectoryName(fullPath);
+        if (directoryName is not null && !Directory.Exists(directoryName))
+        {
+            Directory.CreateDirectory(directoryName);
+        }
+    }
+}
+
+//private class Temp
+//{
+//    private static readonly char[] _pathSeparators = new[]
+//    {
+//        Path.DirectorySeparatorChar,
+//        Path.AltDirectorySeparatorChar
+//    };
+
+//    /// <inheritdoc />
+//    public void CopyFile(string sourceSubpath, string destinationSubpath, bool overwrite = false)
+//    {
+//        if (string.IsNullOrEmpty(sourceSubpath) || PathUtils.HasInvalidPathChars(sourceSubpath) ||
+//            string.IsNullOrEmpty(destinationSubpath) || PathUtils.HasInvalidPathChars(destinationSubpath))
+//        {
+//            return;
+//        }
+
+//        // Relative paths starting with leading slashes are okay
+//        sourceSubpath = sourceSubpath.TrimStart(_pathSeparators);
+//        destinationSubpath = destinationSubpath.TrimStart(_pathSeparators);
+
+//        // Absolute paths not permitted.
+//        if (Path.IsPathRooted(sourceSubpath) || Path.IsPathRooted(destinationSubpath))
+//        {
+//            return;
+//        }
+
+//        string? sourceFullPath = GetFullPath(sourceSubpath);
+//        if (sourceFullPath == null)
+//        {
+//            return;
+//        }
+
+//        string? destinationFullPath = GetFullPath(destinationSubpath);
+//        if (destinationFullPath == null)
+//        {
+//            return;
+//        }
+
+//        File.Copy(sourceFullPath, destinationFullPath, overwrite);
+//    }
+
+//    /// <inheritdoc />
+//    public void DeleteDirectory(string subpath, bool recursive = false)
+//    {
+//        if (subpath == null || PathUtils.HasInvalidPathChars(subpath))
+//        {
+//            return;
+//        }
+
+//        // Relative paths starting with leading slashes are okay
+//        subpath = subpath.TrimStart(_pathSeparators);
+
+//        // Absolute paths not permitted.
+//        if (Path.IsPathRooted(subpath))
+//        {
+//            return;
+//        }
+
+//        string? fullPath = GetFullPath(subpath);
+//        if (fullPath == null || !Directory.Exists(fullPath))
+//        {
+//            return;
+//        }
+
+//        Directory.Delete(fullPath, recursive);
+//    }
+
+//    /// <inheritdoc />
+//    public void DeleteFile(string subpath)
+//    {
+//        if (string.IsNullOrEmpty(subpath) || PathUtils.HasInvalidPathChars(subpath))
+//        {
+//            return;
+//        }
+
+//        // Relative paths starting with leading slashes are okay
+//        subpath = subpath.TrimStart(_pathSeparators);
+
+//        // Absolute paths not permitted.
+//        if (Path.IsPathRooted(subpath))
+//        {
+//            return;
+//        }
+
+//        string? fullPath = GetFullPath(subpath);
+//        if (fullPath == null || !Directory.Exists(fullPath))
+//        {
+//            return;
+//        }
+
+//        File.Delete(fullPath);
+//    }
+
+//    /// <inheritdoc />
+//    public void MoveFile(string sourceSubpath, string destinationSubpath, bool overwrite = false)
+//    {
+//        if (string.IsNullOrEmpty(sourceSubpath) || PathUtils.HasInvalidPathChars(sourceSubpath) ||
+//            string.IsNullOrEmpty(destinationSubpath) || PathUtils.HasInvalidPathChars(destinationSubpath))
+//        {
+//            return;
+//        }
+
+//        // Relative paths starting with leading slashes are okay
+//        sourceSubpath = sourceSubpath.TrimStart(_pathSeparators);
+//        destinationSubpath = destinationSubpath.TrimStart(_pathSeparators);
+
+//        // Absolute paths not permitted.
+//        if (Path.IsPathRooted(sourceSubpath) || Path.IsPathRooted(destinationSubpath))
+//        {
+//            return;
+//        }
+
+//        string? sourceFullPath = GetFullPath(sourceSubpath);
+//        if (sourceFullPath == null)
+//        {
+//            return;
+//        }
+
+//        string? destinationFullPath = GetFullPath(destinationSubpath);
+//        if (destinationFullPath == null)
+//        {
+//            return;
+//        }
+
+//        File.Move(sourceFullPath, destinationFullPath, overwrite);
+//    }
+
+//    /// <inheritdoc />
+//    public void StoreFile(string subpath, Stream stream, bool overwrite = false)
+//    {
+//        if (string.IsNullOrEmpty(subpath) || PathUtils.HasInvalidPathChars(subpath) || stream is null)
+//        {
+//            return;
+//        }
+
+//        // Relative paths starting with leading slashes are okay
+//        subpath = subpath.TrimStart(_pathSeparators);
+
+//        // Absolute paths not permitted.
+//        if (Path.IsPathRooted(subpath))
+//        {
+//            return;
+//        }
+
+//        string? fullPath = GetFullPath(subpath);
+//        if (fullPath == null || !Directory.Exists(fullPath))
+//        {
+//            return;
+//        }
+
+//        using var fileStream = new FileStream(fullPath, overwrite ? FileMode.Create : FileMode.CreateNew, FileAccess.Write);
+//        stream.CopyTo(fileStream);
+//    }
+
+//    private string? GetFullPath(string path)
+//    {
+//        if (PathUtils.PathNavigatesAboveRoot(path))
+//        {
+//            return null;
+//        }
+
+//        string fullPath;
+//        try
+//        {
+//            fullPath = Path.GetFullPath(Path.Combine(Root, path));
+//        }
+//        catch
+//        {
+//            return null;
+//        }
+
+//        if (!IsUnderneathRoot(fullPath))
+//        {
+//            return null;
+//        }
+
+//        return fullPath;
+//    }
+
+//    private bool IsUnderneathRoot(string fullPath)
+//    {
+//        return fullPath.StartsWith(Root, StringComparison.OrdinalIgnoreCase);
+//    }
+//}