diff --git a/Shoko.Server/API/v3/Controllers/FilterController.cs b/Shoko.Server/API/v3/Controllers/FilterController.cs
index dde469488..45c850967 100644
--- a/Shoko.Server/API/v3/Controllers/FilterController.cs
+++ b/Shoko.Server/API/v3/Controllers/FilterController.cs
@@ -142,6 +142,7 @@ public ActionResult<Filter> AddNewFilter(Filter.Input.CreateOrUpdateFilterBody b
                     IWithDateParameter => Filter.FilterExpressionHelp.FilterExpressionParameterType.Date,
                     IWithNumberParameter => Filter.FilterExpressionHelp.FilterExpressionParameterType.Number,
                     IWithStringParameter => Filter.FilterExpressionHelp.FilterExpressionParameterType.String,
+                    IWithStringSetParameter => Filter.FilterExpressionHelp.FilterExpressionParameterType.StringSet,
                     IWithTimeSpanParameter => Filter.FilterExpressionHelp.FilterExpressionParameterType.TimeSpan,
                     _ => null
                 };
diff --git a/Shoko.Server/API/v3/Models/Shoko/Filter.cs b/Shoko.Server/API/v3/Models/Shoko/Filter.cs
index 219ebaf4c..6727017f8 100644
--- a/Shoko.Server/API/v3/Models/Shoko/Filter.cs
+++ b/Shoko.Server/API/v3/Models/Shoko/Filter.cs
@@ -230,6 +230,7 @@ public enum FilterExpressionParameterType
             String,
             TimeSpan,
             Bool,
+            StringSet,
         }
     }
 
diff --git a/Shoko.Server/Filters/FilterExtensions.cs b/Shoko.Server/Filters/FilterExtensions.cs
index fe26a76d5..d4efd4655 100644
--- a/Shoko.Server/Filters/FilterExtensions.cs
+++ b/Shoko.Server/Filters/FilterExtensions.cs
@@ -4,10 +4,10 @@
 using Shoko.Commons.Extensions;
 using Shoko.Models.Enums;
 using Shoko.Models.MediaInfo;
-using Shoko.Plugin.Abstractions.DataModels;
 using Shoko.Server.Models;
 using Shoko.Server.Providers.AniDB;
 using Shoko.Server.Repositories;
+using Shoko.Server.Server;
 using AnimeType = Shoko.Models.Enums.AnimeType;
 using EpisodeType = Shoko.Models.Enums.EpisodeType;
 
@@ -63,6 +63,23 @@ public static Filterable ToFilterable(this SVR_AnimeSeries series)
                 series.GetAvailableImageTypes(),
             PreferredImageTypesDelegate = () =>
                 series.GetPreferredImageTypes(),
+            CharacterAppearancesDelegate = () =>
+                RepoFactory.AniDB_Anime_Character.GetByAnimeID(series.AniDB_ID)
+                    .GroupBy(a => a.Appearance)
+                    .ToDictionary(a => a.Key, a => a.Select(b => b.CharacterID.ToString()).ToHashSet()) as IReadOnlyDictionary<CharacterAppearanceType, IReadOnlySet<string>>,
+            CharacterIDsDelegate = () =>
+                RepoFactory.AniDB_Anime_Character.GetByAnimeID(series.AniDB_ID)
+                    .Select(a => a.CharacterID.ToString())
+                    .ToHashSet(),
+            CreatorIDsDelegate = () =>
+                RepoFactory.AniDB_Anime_Character_Creator.GetByAnimeID(series.AniDB_ID).Select(a => a.CreatorID.ToString())
+                    .Concat(RepoFactory.AniDB_Anime_Staff.GetByAnimeID(series.AniDB_ID).Select(a => a.CreatorID.ToString()))
+                    .ToHashSet(),
+            CreatorRolesDelegate = () =>
+                RepoFactory.AniDB_Anime_Staff.GetByAnimeID(series.AniDB_ID).Select(a => (a.RoleType, a.CreatorID))
+                    .Concat(RepoFactory.AniDB_Anime_Character_Creator.GetByAnimeID(series.AniDB_ID).Select(a => (RoleType: CreatorRoleType.Actor, a.CreatorID)))
+                    .GroupBy(a => a.RoleType)
+                    .ToDictionary(a => a.Key, a => a.Select(b => b.CreatorID.ToString()).ToHashSet()) as IReadOnlyDictionary<CreatorRoleType, IReadOnlySet<string>>,
             HasTmdbLinkDelegate = () =>
                 series.TmdbShowCrossReferences.Count is > 0 || series.TmdbMovieCrossReferences.Count is > 0,
             HasMissingTmdbLinkDelegate = () =>
@@ -215,6 +232,32 @@ public static Filterable ToFilterable(this SVR_AnimeGroup group)
                 group.AvailableImageTypes,
             PreferredImageTypesDelegate = () =>
                 group.PreferredImageTypes,
+            CharacterIDsDelegate = () =>
+                series.SelectMany(ser => RepoFactory.AniDB_Anime_Character.GetByAnimeID(ser.AniDB_ID))
+                    .Select(a => a.CharacterID.ToString())
+                    .ToHashSet(),
+            CharacterAppearancesDelegate = () =>
+                series.SelectMany(ser => RepoFactory.AniDB_Anime_Character.GetByAnimeID(ser.AniDB_ID))
+                    .DistinctBy(a => (a.Appearance, a.CharacterID))
+                    .Select(a => (a.Appearance, a.CharacterID))
+                    .GroupBy(a => a.Appearance)
+                    .ToDictionary(a => a.Key, a => a.Select(b => b.CharacterID.ToString()).ToHashSet()) as IReadOnlyDictionary<CharacterAppearanceType, IReadOnlySet<string>>,
+            CreatorIDsDelegate = () =>
+                series.SelectMany(ser => RepoFactory.AniDB_Anime_Character_Creator.GetByAnimeID(ser.AniDB_ID))
+                    .Select(a => a.CreatorID.ToString())
+                    .Concat(series.SelectMany(ser => RepoFactory.AniDB_Anime_Staff.GetByAnimeID(ser.AniDB_ID).Select(a => a.CreatorID.ToString())))
+                    .ToHashSet(),
+            CreatorRolesDelegate = () =>
+                series.SelectMany(ser => RepoFactory.AniDB_Anime_Staff.GetByAnimeID(ser.AniDB_ID))
+                    .Select(a => (a.RoleType, a.CreatorID))
+                    .DistinctBy(a => (a.RoleType, a.CreatorID))
+                    .Concat(
+                        series.SelectMany(ser => RepoFactory.AniDB_Anime_Character_Creator.GetByAnimeID(ser.AniDB_ID)
+                            .DistinctBy(a => a.CreatorID)
+                            .Select(a => (RoleType: CreatorRoleType.Actor, a.CreatorID)))
+                    )
+                    .GroupBy(a => a.RoleType)
+                    .ToDictionary(a => a.Key, a => a.Select(b => b.CreatorID.ToString()).ToHashSet()) as IReadOnlyDictionary<CreatorRoleType, IReadOnlySet<string>>,
             HasTmdbLinkDelegate = () =>
                 series.Any(a => a.TmdbShowCrossReferences.Count is > 0 || a.TmdbMovieCrossReferences.Count is > 0),
             HasMissingTmdbLinkDelegate = () =>
diff --git a/Shoko.Server/Filters/Filterable.cs b/Shoko.Server/Filters/Filterable.cs
index e4bb11677..972eadc6b 100644
--- a/Shoko.Server/Filters/Filterable.cs
+++ b/Shoko.Server/Filters/Filterable.cs
@@ -3,6 +3,7 @@
 using Shoko.Models.Enums;
 using Shoko.Plugin.Abstractions.Enums;
 using Shoko.Server.Filters.Interfaces;
+using Shoko.Server.Server;
 
 namespace Shoko.Server.Filters;
 
@@ -49,268 +50,300 @@ public class Filterable : IFilterable
     private readonly Lazy<IReadOnlySet<int>> _years;
     private readonly Lazy<IReadOnlySet<ImageEntityType>> _availableImageTypes;
     private readonly Lazy<IReadOnlySet<ImageEntityType>> _preferredImageTypes;
+    private readonly Lazy<IReadOnlySet<string>> _characterIDs;
+    private readonly Lazy<IReadOnlyDictionary<CharacterAppearanceType, IReadOnlySet<string>>> _characterAppearances;
+    private readonly Lazy<IReadOnlySet<string>> _creatorIDs;
+    private readonly Lazy<IReadOnlyDictionary<CreatorRoleType, IReadOnlySet<string>>> _creatorRoles;
 
     public string Name => _name.Value;
 
-    public Func<string> NameDelegate
+    public required Func<string> NameDelegate
     {
         init => _name = new Lazy<string>(value);
     }
 
     public IReadOnlySet<string> Names => _names.Value;
 
-    public Func<IReadOnlySet<string>> NamesDelegate
+    public required Func<IReadOnlySet<string>> NamesDelegate
     {
         init => _names = new Lazy<IReadOnlySet<string>>(value);
     }
 
     public IReadOnlySet<string> AniDBIDs => _aniDbIds.Value;
 
-    public Func<IReadOnlySet<string>> AniDBIDsDelegate
+    public required Func<IReadOnlySet<string>> AniDBIDsDelegate
     {
         init => _aniDbIds = new Lazy<IReadOnlySet<string>>(value);
     }
 
     public string SortingName => _sortingName.Value;
 
-    public Func<string> SortingNameDelegate
+    public required Func<string> SortingNameDelegate
     {
         init => _sortingName = new Lazy<string>(value);
     }
 
     public int SeriesCount => _seriesCount.Value;
 
-    public Func<int> SeriesCountDelegate
+    public required Func<int> SeriesCountDelegate
     {
         init => _seriesCount = new Lazy<int>(value);
     }
 
     public int MissingEpisodes => _missingEpisodes.Value;
 
-    public Func<int> MissingEpisodesDelegate
+    public required Func<int> MissingEpisodesDelegate
     {
         init => _missingEpisodes = new Lazy<int>(value);
     }
 
     public int MissingEpisodesCollecting => _missingEpisodesCollecting.Value;
 
-    public Func<int> MissingEpisodesCollectingDelegate
+    public required Func<int> MissingEpisodesCollectingDelegate
     {
         init => _missingEpisodesCollecting = new Lazy<int>(value);
     }
 
     public int VideoFiles => _videoFiles.Value;
 
-    public Func<int> VideoFilesDelegate
+    public required Func<int> VideoFilesDelegate
     {
         init => _videoFiles = new Lazy<int>(value);
     }
 
     public IReadOnlySet<string> Tags => _tags.Value;
 
-    public Func<IReadOnlySet<string>> TagsDelegate
+    public required Func<IReadOnlySet<string>> TagsDelegate
     {
         init => _tags = new Lazy<IReadOnlySet<string>>(value);
     }
 
     public IReadOnlySet<string> CustomTags => _customTags.Value;
 
-    public Func<IReadOnlySet<string>> CustomTagsDelegate
+    public required Func<IReadOnlySet<string>> CustomTagsDelegate
     {
         init => _customTags = new Lazy<IReadOnlySet<string>>(value);
     }
 
     public IReadOnlySet<int> Years => _years.Value;
 
-    public Func<IReadOnlySet<int>> YearsDelegate
+    public required Func<IReadOnlySet<int>> YearsDelegate
     {
         init => _years = new Lazy<IReadOnlySet<int>>(value);
     }
 
     public IReadOnlySet<(int year, AnimeSeason season)> Seasons => _seasons.Value;
 
-    public Func<IReadOnlySet<(int year, AnimeSeason season)>> SeasonsDelegate
+    public required Func<IReadOnlySet<(int year, AnimeSeason season)>> SeasonsDelegate
     {
         init => _seasons = new Lazy<IReadOnlySet<(int year, AnimeSeason season)>>(value);
     }
 
     public IReadOnlySet<ImageEntityType> AvailableImageTypes => _availableImageTypes.Value;
 
-    public Func<IReadOnlySet<ImageEntityType>> AvailableImageTypesDelegate
+    public required Func<IReadOnlySet<ImageEntityType>> AvailableImageTypesDelegate
     {
         init => _availableImageTypes = new Lazy<IReadOnlySet<ImageEntityType>>(value);
     }
 
     public IReadOnlySet<ImageEntityType> PreferredImageTypes => _preferredImageTypes.Value;
 
-    public Func<IReadOnlySet<ImageEntityType>> PreferredImageTypesDelegate
+    public required Func<IReadOnlySet<ImageEntityType>> PreferredImageTypesDelegate
     {
         init => _preferredImageTypes = new Lazy<IReadOnlySet<ImageEntityType>>(value);
     }
 
+    public IReadOnlySet<string> CharacterIDs => _characterIDs.Value;
+
+    public required Func<IReadOnlySet<string>> CharacterIDsDelegate
+    {
+        init => _characterIDs = new Lazy<IReadOnlySet<string>>(value);
+    }
+
+    public IReadOnlyDictionary<CharacterAppearanceType, IReadOnlySet<string>> CharacterAppearances => _characterAppearances.Value;
+
+    public required Func<IReadOnlyDictionary<CharacterAppearanceType, IReadOnlySet<string>>> CharacterAppearancesDelegate
+    {
+        init => _characterAppearances = new Lazy<IReadOnlyDictionary<CharacterAppearanceType, IReadOnlySet<string>>>(value);
+    }
+
+    public IReadOnlySet<string> CreatorIDs => _creatorIDs.Value;
+
+    public required Func<IReadOnlySet<string>> CreatorIDsDelegate
+    {
+        init => _creatorIDs = new Lazy<IReadOnlySet<string>>(value);
+    }
+
+    public IReadOnlyDictionary<CreatorRoleType, IReadOnlySet<string>> CreatorRoles => _creatorRoles.Value;
+
+    public required Func<IReadOnlyDictionary<CreatorRoleType, IReadOnlySet<string>>> CreatorRolesDelegate
+    {
+        init => _creatorRoles = new Lazy<IReadOnlyDictionary<CreatorRoleType, IReadOnlySet<string>>>(value);
+    }
+
     public bool HasTmdbLink => _hasTmdbLink.Value;
 
-    public Func<bool> HasTmdbLinkDelegate
+    public required Func<bool> HasTmdbLinkDelegate
     {
         init => _hasTmdbLink = new Lazy<bool>(value);
     }
 
     public bool HasMissingTmdbLink => _hasMissingTmdbLink.Value;
 
-    public Func<bool> HasMissingTmdbLinkDelegate
+    public required Func<bool> HasMissingTmdbLinkDelegate
     {
         init => _hasMissingTmdbLink = new Lazy<bool>(value);
     }
 
     public int AutomaticTmdbEpisodeLinks => _automaticTmdbEpisodeLinks.Value;
 
-    public Func<int> AutomaticTmdbEpisodeLinksDelegate
+    public required Func<int> AutomaticTmdbEpisodeLinksDelegate
     {
         init => _automaticTmdbEpisodeLinks = new Lazy<int>(value);
     }
 
     public int UserVerifiedTmdbEpisodeLinks => _userVerifiedTmdbEpisodeLinks.Value;
 
-    public Func<int> UserVerifiedTmdbEpisodeLinksDelegate
+    public required Func<int> UserVerifiedTmdbEpisodeLinksDelegate
     {
         init => _userVerifiedTmdbEpisodeLinks = new Lazy<int>(value);
     }
 
     public bool HasTraktLink => _hasTraktLink.Value;
 
-    public Func<bool> HasTraktLinkDelegate
+    public required Func<bool> HasTraktLinkDelegate
     {
         init => _hasTraktLink = new Lazy<bool>(value);
     }
 
     public bool HasMissingTraktLink => _hasMissingTraktLink.Value;
 
-    public Func<bool> HasMissingTraktLinkDelegate
+    public required Func<bool> HasMissingTraktLinkDelegate
     {
         init => _hasMissingTraktLink = new Lazy<bool>(value);
     }
 
     public bool IsFinished => _isFinished.Value;
 
-    public Func<bool> IsFinishedDelegate
+    public required Func<bool> IsFinishedDelegate
     {
         init => _isFinished = new Lazy<bool>(value);
     }
 
     public DateTime? AirDate => _airDate.Value;
 
-    public Func<DateTime?> AirDateDelegate
+    public required Func<DateTime?> AirDateDelegate
     {
         init => _airDate = new Lazy<DateTime?>(value);
     }
 
     public DateTime? LastAirDate => _lastAirDate.Value;
 
-    public Func<DateTime?> LastAirDateDelegate
+    public required Func<DateTime?> LastAirDateDelegate
     {
         init => _lastAirDate = new Lazy<DateTime?>(value);
     }
 
     public DateTime AddedDate => _addedDate.Value;
 
-    public Func<DateTime> AddedDateDelegate
+    public required Func<DateTime> AddedDateDelegate
     {
         init => _addedDate = new Lazy<DateTime>(value);
     }
 
     public DateTime LastAddedDate => _lastAddedDate.Value;
 
-    public Func<DateTime> LastAddedDateDelegate
+    public required Func<DateTime> LastAddedDateDelegate
     {
         init => _lastAddedDate = new Lazy<DateTime>(value);
     }
 
     public int EpisodeCount => _episodeCount.Value;
 
-    public Func<int> EpisodeCountDelegate
+    public required Func<int> EpisodeCountDelegate
     {
         init => _episodeCount = new Lazy<int>(value);
     }
 
     public int TotalEpisodeCount => _totalEpisodeCount.Value;
 
-    public Func<int> TotalEpisodeCountDelegate
+    public required Func<int> TotalEpisodeCountDelegate
     {
         init => _totalEpisodeCount = new Lazy<int>(value);
     }
 
     public decimal LowestAniDBRating => _lowestAniDBRating.Value;
 
-    public Func<decimal> LowestAniDBRatingDelegate
+    public required Func<decimal> LowestAniDBRatingDelegate
     {
         init => _lowestAniDBRating = new Lazy<decimal>(value);
     }
 
     public decimal HighestAniDBRating => _highestAniDBRating.Value;
 
-    public Func<decimal> HighestAniDBRatingDelegate
+    public required Func<decimal> HighestAniDBRatingDelegate
     {
         init => _highestAniDBRating = new Lazy<decimal>(value);
     }
 
     public decimal AverageAniDBRating => _averageAniDBRating.Value;
 
-    public Func<decimal> AverageAniDBRatingDelegate
+    public required Func<decimal> AverageAniDBRatingDelegate
     {
         init => _averageAniDBRating = new Lazy<decimal>(value);
     }
 
     public IReadOnlySet<string> VideoSources => _videoSources.Value;
 
-    public Func<IReadOnlySet<string>> VideoSourcesDelegate
+    public required Func<IReadOnlySet<string>> VideoSourcesDelegate
     {
         init => _videoSources = new Lazy<IReadOnlySet<string>>(value);
     }
 
     public IReadOnlySet<string> SharedVideoSources => _sharedVideoSources.Value;
 
-    public Func<IReadOnlySet<string>> SharedVideoSourcesDelegate
+    public required Func<IReadOnlySet<string>> SharedVideoSourcesDelegate
     {
         init => _sharedVideoSources = new Lazy<IReadOnlySet<string>>(value);
     }
 
     public IReadOnlySet<string> AnimeTypes => _animeTypes.Value;
 
-    public Func<IReadOnlySet<string>> AnimeTypesDelegate
+    public required Func<IReadOnlySet<string>> AnimeTypesDelegate
     {
         init => _animeTypes = new Lazy<IReadOnlySet<string>>(value);
     }
 
     public IReadOnlySet<string> AudioLanguages => _audioLanguages.Value;
 
-    public Func<IReadOnlySet<string>> AudioLanguagesDelegate
+    public required Func<IReadOnlySet<string>> AudioLanguagesDelegate
     {
         init => _audioLanguages = new Lazy<IReadOnlySet<string>>(value);
     }
 
     public IReadOnlySet<string> SharedAudioLanguages => _sharedAudioLanguages.Value;
 
-    public Func<IReadOnlySet<string>> SharedAudioLanguagesDelegate
+    public required Func<IReadOnlySet<string>> SharedAudioLanguagesDelegate
     {
         init => _sharedAudioLanguages = new Lazy<IReadOnlySet<string>>(value);
     }
 
     public IReadOnlySet<string> SubtitleLanguages => _subtitleLanguages.Value;
 
-    public Func<IReadOnlySet<string>> SubtitleLanguagesDelegate
+    public required Func<IReadOnlySet<string>> SubtitleLanguagesDelegate
     {
         init => _subtitleLanguages = new Lazy<IReadOnlySet<string>>(value);
     }
 
     public IReadOnlySet<string> SharedSubtitleLanguages => _sharedSubtitleLanguages.Value;
 
-    public Func<IReadOnlySet<string>> SharedSubtitleLanguagesDelegate
+    public required Func<IReadOnlySet<string>> SharedSubtitleLanguagesDelegate
     {
         init => _sharedSubtitleLanguages = new Lazy<IReadOnlySet<string>>(value);
     }
 
     public IReadOnlySet<string> Resolutions => _resolutions.Value;
-    public Func<IReadOnlySet<string>> ResolutionsDelegate
+    public required Func<IReadOnlySet<string>> ResolutionsDelegate
     {
         init
         {
@@ -320,21 +353,21 @@ public Func<IReadOnlySet<string>> ResolutionsDelegate
 
     public IReadOnlySet<string> ImportFolderIDs => _importFolderIDs.Value;
 
-    public Func<IReadOnlySet<string>> ImportFolderIDsDelegate
+    public required Func<IReadOnlySet<string>> ImportFolderIDsDelegate
     {
         init => _importFolderIDs = new Lazy<IReadOnlySet<string>>(value);
     }
 
     public IReadOnlySet<string> ImportFolderNames => _importFolderNames.Value;
 
-    public Func<IReadOnlySet<string>> ImportFolderNamesDelegate
+    public required Func<IReadOnlySet<string>> ImportFolderNamesDelegate
     {
         init => _importFolderNames = new Lazy<IReadOnlySet<string>>(value);
     }
 
     public IReadOnlySet<string> FilePaths => _filePaths.Value;
 
-    public Func<IReadOnlySet<string>> FilePathsDelegate
+    public required Func<IReadOnlySet<string>> FilePathsDelegate
     {
         init => _filePaths = new Lazy<IReadOnlySet<string>>(value);
     }
diff --git a/Shoko.Server/Filters/Info/HasCharacterExpression.cs b/Shoko.Server/Filters/Info/HasCharacterExpression.cs
new file mode 100644
index 000000000..b0dcbd166
--- /dev/null
+++ b/Shoko.Server/Filters/Info/HasCharacterExpression.cs
@@ -0,0 +1,70 @@
+using System;
+using Shoko.Server.Filters.Interfaces;
+
+namespace Shoko.Server.Filters.Info;
+
+public class HasCharacterExpression : FilterExpression<bool>, IWithStringParameter
+{
+    public HasCharacterExpression(string characterID)
+    {
+        CharacterID = characterID;
+    }
+
+    public HasCharacterExpression() { }
+
+    public string CharacterID { get; set; }
+    public override bool TimeDependent => false;
+    public override bool UserDependent => false;
+    public override string HelpDescription => "This condition passes if the filterable has a character.";
+
+    string IWithStringParameter.Parameter
+    {
+        get => CharacterID;
+        set => CharacterID = value;
+    }
+
+    public override bool Evaluate(IFilterable filterable, IFilterableUserInfo userInfo)
+    {
+        return filterable.CharacterIDs.Contains(CharacterID);
+    }
+
+    protected bool Equals(HasCharacterExpression other)
+    {
+        return base.Equals(other) && CharacterID == other.CharacterID;
+    }
+
+    public override bool Equals(object obj)
+    {
+        if (ReferenceEquals(null, obj))
+        {
+            return false;
+        }
+
+        if (ReferenceEquals(this, obj))
+        {
+            return true;
+        }
+
+        if (obj.GetType() != this.GetType())
+        {
+            return false;
+        }
+
+        return Equals((HasCharacterExpression)obj);
+    }
+
+    public override int GetHashCode()
+    {
+        return HashCode.Combine(base.GetHashCode(), CharacterID);
+    }
+
+    public static bool operator ==(HasCharacterExpression left, HasCharacterExpression right)
+    {
+        return Equals(left, right);
+    }
+
+    public static bool operator !=(HasCharacterExpression left, HasCharacterExpression right)
+    {
+        return !Equals(left, right);
+    }
+}
diff --git a/Shoko.Server/Filters/Info/HasCharacterWithAppearanceExpression.cs b/Shoko.Server/Filters/Info/HasCharacterWithAppearanceExpression.cs
new file mode 100644
index 000000000..26abb3203
--- /dev/null
+++ b/Shoko.Server/Filters/Info/HasCharacterWithAppearanceExpression.cs
@@ -0,0 +1,79 @@
+using System;
+using Shoko.Server.Filters.Interfaces;
+using Shoko.Server.Server;
+
+namespace Shoko.Server.Filters.Info;
+
+public class HasCharacterWithAppearanceExpression : FilterExpression<bool>, IWithStringParameter, IWithSecondStringParameter
+{
+    public HasCharacterWithAppearanceExpression(string characterID, CharacterAppearanceType appearance)
+    {
+        CharacterID = characterID;
+        Appearance = appearance;
+    }
+
+    public HasCharacterWithAppearanceExpression() { }
+
+    public string CharacterID { get; set; }
+    public CharacterAppearanceType Appearance { get; set; }
+    public override bool TimeDependent => false;
+    public override bool UserDependent => false;
+    public override string HelpDescription => "This condition passes if the filterable has a character with the specified appearance.";
+
+    string IWithStringParameter.Parameter
+    {
+        get => CharacterID;
+        set => CharacterID = value;
+    }
+
+    string IWithSecondStringParameter.SecondParameter
+    {
+        get => Appearance.ToString();
+        set => Appearance = Enum.Parse<CharacterAppearanceType>(value);
+    }
+
+    public override bool Evaluate(IFilterable filterable, IFilterableUserInfo userInfo)
+    {
+        return filterable.CharacterAppearances.TryGetValue(Appearance, out var appearances) && appearances.Contains(CharacterID);
+    }
+
+    protected bool Equals(HasCharacterWithAppearanceExpression other)
+    {
+        return base.Equals(other) && CharacterID == other.CharacterID && Appearance == other.Appearance;
+    }
+
+    public override bool Equals(object obj)
+    {
+        if (ReferenceEquals(null, obj))
+        {
+            return false;
+        }
+
+        if (ReferenceEquals(this, obj))
+        {
+            return true;
+        }
+
+        if (obj.GetType() != this.GetType())
+        {
+            return false;
+        }
+
+        return Equals((HasCharacterWithAppearanceExpression)obj);
+    }
+
+    public override int GetHashCode()
+    {
+        return HashCode.Combine(base.GetHashCode(), CharacterID, (int)Appearance);
+    }
+
+    public static bool operator ==(HasCharacterWithAppearanceExpression left, HasCharacterWithAppearanceExpression right)
+    {
+        return Equals(left, right);
+    }
+
+    public static bool operator !=(HasCharacterWithAppearanceExpression left, HasCharacterWithAppearanceExpression right)
+    {
+        return !Equals(left, right);
+    }
+}
diff --git a/Shoko.Server/Filters/Info/HasCreatorExpression.cs b/Shoko.Server/Filters/Info/HasCreatorExpression.cs
new file mode 100644
index 000000000..1e39a196c
--- /dev/null
+++ b/Shoko.Server/Filters/Info/HasCreatorExpression.cs
@@ -0,0 +1,70 @@
+using System;
+using Shoko.Server.Filters.Interfaces;
+
+namespace Shoko.Server.Filters.Info;
+
+public class HasCreatorExpression : FilterExpression<bool>, IWithStringParameter
+{
+    public HasCreatorExpression(string creatorID)
+    {
+        CreatorID = creatorID;
+    }
+
+    public HasCreatorExpression() { }
+
+    public string CreatorID { get; set; }
+    public override bool TimeDependent => false;
+    public override bool UserDependent => false;
+    public override string HelpDescription => "This condition passes if the filterable has a creator.";
+
+    string IWithStringParameter.Parameter
+    {
+        get => CreatorID;
+        set => CreatorID = value;
+    }
+
+    public override bool Evaluate(IFilterable filterable, IFilterableUserInfo userInfo)
+    {
+        return filterable.CreatorIDs.Contains(CreatorID);
+    }
+
+    protected bool Equals(HasCreatorExpression other)
+    {
+        return base.Equals(other) && CreatorID == other.CreatorID;
+    }
+
+    public override bool Equals(object obj)
+    {
+        if (ReferenceEquals(null, obj))
+        {
+            return false;
+        }
+
+        if (ReferenceEquals(this, obj))
+        {
+            return true;
+        }
+
+        if (obj.GetType() != this.GetType())
+        {
+            return false;
+        }
+
+        return Equals((HasCreatorExpression)obj);
+    }
+
+    public override int GetHashCode()
+    {
+        return HashCode.Combine(base.GetHashCode(), CreatorID);
+    }
+
+    public static bool operator ==(HasCreatorExpression left, HasCreatorExpression right)
+    {
+        return Equals(left, right);
+    }
+
+    public static bool operator !=(HasCreatorExpression left, HasCreatorExpression right)
+    {
+        return !Equals(left, right);
+    }
+}
diff --git a/Shoko.Server/Filters/Info/HasCreatorWithRoleExpression.cs b/Shoko.Server/Filters/Info/HasCreatorWithRoleExpression.cs
new file mode 100644
index 000000000..8f835a528
--- /dev/null
+++ b/Shoko.Server/Filters/Info/HasCreatorWithRoleExpression.cs
@@ -0,0 +1,79 @@
+using System;
+using Shoko.Server.Filters.Interfaces;
+using Shoko.Server.Server;
+
+namespace Shoko.Server.Filters.Info;
+
+public class HasCreatorWithRoleExpression : FilterExpression<bool>, IWithStringParameter, IWithSecondStringParameter
+{
+    public HasCreatorWithRoleExpression(string creatorID, CreatorRoleType role)
+    {
+        CreatorID = creatorID;
+        Role = role;
+    }
+
+    public HasCreatorWithRoleExpression() { }
+
+    public string CreatorID { get; set; }
+    public CreatorRoleType Role { get; set; }
+    public override bool TimeDependent => false;
+    public override bool UserDependent => false;
+    public override string HelpDescription => "This condition passes if the filterable has a creator with the specified role.";
+
+    string IWithStringParameter.Parameter
+    {
+        get => CreatorID;
+        set => CreatorID = value;
+    }
+
+    string IWithSecondStringParameter.SecondParameter
+    {
+        get => Role.ToString();
+        set => Role = Enum.Parse<CreatorRoleType>(value);
+    }
+
+    public override bool Evaluate(IFilterable filterable, IFilterableUserInfo userInfo)
+    {
+        return filterable.CreatorRoles.TryGetValue(Role, out var roles) && roles.Contains(CreatorID);
+    }
+
+    protected bool Equals(HasCreatorWithRoleExpression other)
+    {
+        return base.Equals(other) && CreatorID == other.CreatorID && Role == other.Role;
+    }
+
+    public override bool Equals(object obj)
+    {
+        if (ReferenceEquals(null, obj))
+        {
+            return false;
+        }
+
+        if (ReferenceEquals(this, obj))
+        {
+            return true;
+        }
+
+        if (obj.GetType() != this.GetType())
+        {
+            return false;
+        }
+
+        return Equals((HasCreatorWithRoleExpression)obj);
+    }
+
+    public override int GetHashCode()
+    {
+        return HashCode.Combine(base.GetHashCode(), CreatorID, (int)Role);
+    }
+
+    public static bool operator ==(HasCreatorWithRoleExpression left, HasCreatorWithRoleExpression right)
+    {
+        return Equals(left, right);
+    }
+
+    public static bool operator !=(HasCreatorWithRoleExpression left, HasCreatorWithRoleExpression right)
+    {
+        return !Equals(left, right);
+    }
+}
diff --git a/Shoko.Server/Filters/Interfaces/IFilterable.cs b/Shoko.Server/Filters/Interfaces/IFilterable.cs
index 03380def5..931ca21db 100644
--- a/Shoko.Server/Filters/Interfaces/IFilterable.cs
+++ b/Shoko.Server/Filters/Interfaces/IFilterable.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using Shoko.Models.Enums;
 using Shoko.Plugin.Abstractions.Enums;
+using Shoko.Server.Server;
 
 namespace Shoko.Server.Filters.Interfaces;
 
@@ -211,4 +212,24 @@ public interface IFilterable
     /// Relative File Paths
     /// </summary>
     IReadOnlySet<string> FilePaths { get; }
+
+    /// <summary>
+    /// Character IDs
+    /// </summary>
+    IReadOnlySet<string> CharacterIDs { get; }
+
+    /// <summary>
+    /// Character Appearance Types
+    /// </summary>
+    IReadOnlyDictionary<CharacterAppearanceType, IReadOnlySet<string>> CharacterAppearances { get; }
+
+    /// <summary>
+    /// Creator IDs
+    /// </summary>
+    IReadOnlySet<string> CreatorIDs { get; }
+
+    /// <summary>
+    /// Creator Roles
+    /// </summary>
+    IReadOnlyDictionary<CreatorRoleType, IReadOnlySet<string>> CreatorRoles { get; }
 }
diff --git a/Shoko.Server/Filters/Interfaces/IWithStringSetParameter.cs b/Shoko.Server/Filters/Interfaces/IWithStringSetParameter.cs
new file mode 100644
index 000000000..a11eb798d
--- /dev/null
+++ b/Shoko.Server/Filters/Interfaces/IWithStringSetParameter.cs
@@ -0,0 +1,8 @@
+using System.Collections.Generic;
+
+namespace Shoko.Server.Filters.Interfaces;
+
+public interface IWithStringSetParameter
+{
+    IReadOnlySet<string> Parameter { get; set; }
+}
diff --git a/Shoko.Server/Filters/Logic/StringSets/SetOverlapsExpression.cs b/Shoko.Server/Filters/Logic/StringSets/SetOverlapsExpression.cs
new file mode 100644
index 000000000..19e7ee432
--- /dev/null
+++ b/Shoko.Server/Filters/Logic/StringSets/SetOverlapsExpression.cs
@@ -0,0 +1,76 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Shoko.Server.Filters.Interfaces;
+
+namespace Shoko.Server.Filters.Logic.StringSets;
+
+public class SetOverlapsExpression : FilterExpression<bool>, IWithStringSetSelectorParameter, IWithStringSetParameter
+{
+    public SetOverlapsExpression(FilterExpression<IReadOnlySet<string>> left, IReadOnlySet<string> parameter)
+    {
+        Left = left;
+        Parameter = parameter;
+    }
+
+    public SetOverlapsExpression() { }
+
+    public FilterExpression<IReadOnlySet<string>> Left { get; set; }
+    public IReadOnlySet<string> Parameter { get; set; }
+    public override bool TimeDependent => Left.TimeDependent;
+    public override bool UserDependent => Left.UserDependent;
+    public override string HelpDescription => "This condition passes if any of the values in the left selector overlaps with the parameter";
+    public override FilterExpressionGroup Group => FilterExpressionGroup.Logic;
+
+    public override bool Evaluate(IFilterable filterable, IFilterableUserInfo userInfo)
+    {
+        var left = Left.Evaluate(filterable, userInfo);
+        var right = Parameter;
+        return left.Overlaps(right);
+    }
+
+    protected bool Equals(SetOverlapsExpression other)
+    {
+        return base.Equals(other) && Equals(Left, other.Left) && Parameter.SetEquals(other.Parameter);
+    }
+
+    public override bool Equals(object obj)
+    {
+        if (ReferenceEquals(null, obj))
+        {
+            return false;
+        }
+
+        if (ReferenceEquals(this, obj))
+        {
+            return true;
+        }
+
+        if (obj.GetType() != this.GetType())
+        {
+            return false;
+        }
+
+        return Equals((SetOverlapsExpression)obj);
+    }
+
+    public override int GetHashCode()
+    {
+        return HashCode.Combine(base.GetHashCode(), Left, Parameter);
+    }
+
+    public static bool operator ==(SetOverlapsExpression left, SetOverlapsExpression right)
+    {
+        return Equals(left, right);
+    }
+
+    public static bool operator !=(SetOverlapsExpression left, SetOverlapsExpression right)
+    {
+        return !Equals(left, right);
+    }
+
+    public override bool IsType(FilterExpression expression)
+    {
+        return expression is SetOverlapsExpression exp && Left.IsType(exp.Left);
+    }
+}
diff --git a/Shoko.Server/Filters/Logic/Strings/StringInExpression.cs b/Shoko.Server/Filters/Logic/Strings/StringInExpression.cs
new file mode 100644
index 000000000..5841f41db
--- /dev/null
+++ b/Shoko.Server/Filters/Logic/Strings/StringInExpression.cs
@@ -0,0 +1,76 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Shoko.Server.Filters.Interfaces;
+
+namespace Shoko.Server.Filters.Logic.StringSets;
+
+public class StringInExpression : FilterExpression<bool>, IWithStringSelectorParameter, IWithStringSetParameter
+{
+    public StringInExpression(FilterExpression<string> left, IReadOnlySet<string> parameter)
+    {
+        Left = left;
+        Parameter = parameter;
+    }
+
+    public StringInExpression() { }
+
+    public FilterExpression<string> Left { get; set; }
+    public IReadOnlySet<string> Parameter { get; set; }
+    public override bool TimeDependent => Left.TimeDependent;
+    public override bool UserDependent => Left.UserDependent;
+    public override string HelpDescription => "This condition passes if any of the value from the left selector is contained within the parameter set";
+    public override FilterExpressionGroup Group => FilterExpressionGroup.Logic;
+
+    public override bool Evaluate(IFilterable filterable, IFilterableUserInfo userInfo)
+    {
+        var left = Left.Evaluate(filterable, userInfo);
+        var right = Parameter;
+        return right.Contains(left);
+    }
+
+    protected bool Equals(StringInExpression other)
+    {
+        return base.Equals(other) && Equals(Left, other.Left) && Parameter.SetEquals(other.Parameter);
+    }
+
+    public override bool Equals(object obj)
+    {
+        if (ReferenceEquals(null, obj))
+        {
+            return false;
+        }
+
+        if (ReferenceEquals(this, obj))
+        {
+            return true;
+        }
+
+        if (obj.GetType() != this.GetType())
+        {
+            return false;
+        }
+
+        return Equals((StringInExpression)obj);
+    }
+
+    public override int GetHashCode()
+    {
+        return HashCode.Combine(base.GetHashCode(), Left, Parameter);
+    }
+
+    public static bool operator ==(StringInExpression left, StringInExpression right)
+    {
+        return Equals(left, right);
+    }
+
+    public static bool operator !=(StringInExpression left, StringInExpression right)
+    {
+        return !Equals(left, right);
+    }
+
+    public override bool IsType(FilterExpression expression)
+    {
+        return expression is StringInExpression exp && Left.IsType(exp.Left);
+    }
+}
diff --git a/Shoko.Server/Filters/Selectors/StringSetSelectors/CharacterIDsSelector.cs b/Shoko.Server/Filters/Selectors/StringSetSelectors/CharacterIDsSelector.cs
new file mode 100644
index 000000000..92d34cd86
--- /dev/null
+++ b/Shoko.Server/Filters/Selectors/StringSetSelectors/CharacterIDsSelector.cs
@@ -0,0 +1,57 @@
+using System.Collections.Generic;
+using Shoko.Server.Filters.Interfaces;
+
+namespace Shoko.Server.Filters.Selectors.StringSetSelectors;
+
+public class CharacterIDsSelector : FilterExpression<IReadOnlySet<string>>
+{
+    public override bool TimeDependent => false;
+    public override bool UserDependent => false;
+    public override string HelpDescription => "This returns a set of all the character IDs in a filterable.";
+    public override FilterExpressionGroup Group => FilterExpressionGroup.Selector;
+
+    public override IReadOnlySet<string> Evaluate(IFilterable filterable, IFilterableUserInfo userInfo)
+    {
+        return filterable.CharacterIDs;
+    }
+
+    protected bool Equals(CharacterIDsSelector other)
+    {
+        return base.Equals(other);
+    }
+
+    public override bool Equals(object obj)
+    {
+        if (ReferenceEquals(null, obj))
+        {
+            return false;
+        }
+
+        if (ReferenceEquals(this, obj))
+        {
+            return true;
+        }
+
+        if (obj.GetType() != this.GetType())
+        {
+            return false;
+        }
+
+        return Equals((CharacterIDsSelector)obj);
+    }
+
+    public override int GetHashCode()
+    {
+        return GetType().FullName!.GetHashCode();
+    }
+
+    public static bool operator ==(CharacterIDsSelector left, CharacterIDsSelector right)
+    {
+        return Equals(left, right);
+    }
+
+    public static bool operator !=(CharacterIDsSelector left, CharacterIDsSelector right)
+    {
+        return !Equals(left, right);
+    }
+}
diff --git a/Shoko.Server/Filters/Selectors/StringSetSelectors/CreatorIDsSelector.cs b/Shoko.Server/Filters/Selectors/StringSetSelectors/CreatorIDsSelector.cs
new file mode 100644
index 000000000..e541fec0a
--- /dev/null
+++ b/Shoko.Server/Filters/Selectors/StringSetSelectors/CreatorIDsSelector.cs
@@ -0,0 +1,57 @@
+using System.Collections.Generic;
+using Shoko.Server.Filters.Interfaces;
+
+namespace Shoko.Server.Filters.Selectors.StringSetSelectors;
+
+public class CreatorIDsSelector : FilterExpression<IReadOnlySet<string>>
+{
+    public override bool TimeDependent => false;
+    public override bool UserDependent => false;
+    public override string HelpDescription => "This returns a set of all the creator IDs in a filterable.";
+    public override FilterExpressionGroup Group => FilterExpressionGroup.Selector;
+
+    public override IReadOnlySet<string> Evaluate(IFilterable filterable, IFilterableUserInfo userInfo)
+    {
+        return filterable.CreatorIDs;
+    }
+
+    protected bool Equals(CreatorIDsSelector other)
+    {
+        return base.Equals(other);
+    }
+
+    public override bool Equals(object obj)
+    {
+        if (ReferenceEquals(null, obj))
+        {
+            return false;
+        }
+
+        if (ReferenceEquals(this, obj))
+        {
+            return true;
+        }
+
+        if (obj.GetType() != this.GetType())
+        {
+            return false;
+        }
+
+        return Equals((CreatorIDsSelector)obj);
+    }
+
+    public override int GetHashCode()
+    {
+        return GetType().FullName!.GetHashCode();
+    }
+
+    public static bool operator ==(CreatorIDsSelector left, CreatorIDsSelector right)
+    {
+        return Equals(left, right);
+    }
+
+    public static bool operator !=(CreatorIDsSelector left, CreatorIDsSelector right)
+    {
+        return !Equals(left, right);
+    }
+}