diff --git a/Shoko.Server/API/v2/Models/common/Filters.cs b/Shoko.Server/API/v2/Models/common/Filters.cs
index 96086fda2..1e5695a52 100644
--- a/Shoko.Server/API/v2/Models/common/Filters.cs
+++ b/Shoko.Server/API/v2/Models/common/Filters.cs
@@ -28,7 +28,7 @@ public Filters()
 
     internal static Filters GenerateFromGroupFilter(HttpContext ctx, FilterPreset gf, int uid, bool nocast,
         bool notag, int level,
-        bool all, bool allpic, int pic, TagFilter.Filter tagfilter, Dictionary<FilterPreset, IEnumerable<IGrouping<int, int>>> evaluatedResults = null)
+        bool all, bool allpic, int pic, TagFilter.Filter tagfilter, IDictionary<FilterPreset, IEnumerable<IGrouping<int, int>>> evaluatedResults = null)
     {
         var f = new Filters { id = gf.FilterPresetID, name = gf.Name };
         var hideCategories = ctx.GetUser().GetHideCategories();
diff --git a/Shoko.Server/Filters/FilterEvaluator.cs b/Shoko.Server/Filters/FilterEvaluator.cs
index bb8ef3dcf..84e49fe14 100644
--- a/Shoko.Server/Filters/FilterEvaluator.cs
+++ b/Shoko.Server/Filters/FilterEvaluator.cs
@@ -89,55 +89,72 @@ public Dictionary<FilterPreset, IEnumerable<IGrouping<int, int>>> BatchEvaluateF
         ArgumentNullException.ThrowIfNull(filters);
         if (!filters.Any()) return new Dictionary<FilterPreset, IEnumerable<IGrouping<int, int>>>();
         // count it as a user filter if it needs to sort using a user-dependent expression
-        var needsUser = filters.Any(a => (a?.Expression?.UserDependent ?? false) || skipSorting && (a?.SortingExpression?.UserDependent ?? false));
+        var hasSeries = filters.Any(a => a.ApplyAtSeriesLevel);
+        var seriesNeedsUser = hasSeries && filters.Any(a =>
+        {
+            if (!a.ApplyAtSeriesLevel) return false;
+            if (a.Expression?.UserDependent ?? false) return true;
+            if (skipSorting) return false;
+            return a.SortingExpression?.UserDependent ?? false;
+        });
+        var hasGroups = filters.Any(a => !a.ApplyAtSeriesLevel);
+        var groupsNeedUser = hasGroups && filters.Any(a =>
+        {
+            if (a.ApplyAtSeriesLevel) return false;
+            if (a.Expression?.UserDependent ?? false) return true;
+            if (skipSorting) return false;
+            return a.SortingExpression?.UserDependent ?? false;
+        });
+        var needsUser = seriesNeedsUser || groupsNeedUser;
         if (needsUser && userID == null) throw new ArgumentNullException(nameof(userID));
 
         var user = userID != null ? RepoFactory.JMMUser.GetByID(userID.Value) : null;
         ILookup<int, CrossRef_AniDB_Other> movieDBMappings;
         using (var session = DatabaseFactory.SessionFactory.OpenStatelessSession())
-        {
             movieDBMappings = RepoFactory.CrossRef_AniDB_Other.GetByAnimeIDsAndType(session.Wrap(), null, CrossRefType.MovieDB);
-        }
 
-        ParallelQuery<FilterableWithID> series = null;
-        ParallelQuery<FilterableWithID> groups = null;
+        FilterableWithID[] series = null;
+        if (hasSeries)
+        {
+            var allowedSeries = _series.GetAll().Where(a => user?.AllowedSeries(a) ?? true);
+            series = seriesNeedsUser
+                ? allowedSeries.Select(a =>
+                    new FilterableWithID(a.AnimeSeriesID, a.AnimeGroupID, a.ToFilterable(movieDBMappings), a.ToFilterableUserInfo(userID.Value))).ToArray()
+                : allowedSeries.Select(a => new FilterableWithID(a.AnimeSeriesID, a.AnimeGroupID, a.ToFilterable(movieDBMappings))).ToArray();
+        }
 
-        var filterables = filters.ToDictionary(filter => filter, filter =>
+        FilterableWithID[] groups = null;
+        if (hasGroups)
         {
-            var filterNeedsUser = (filter.Expression?.UserDependent ?? false) || skipSorting && (filter?.SortingExpression?.UserDependent ?? false);
-            return filter.ApplyAtSeriesLevel switch
-            {
-                true when filterNeedsUser => series ??= _series.GetAll().AsParallel().Where(a => user?.AllowedSeries(a) ?? true)
-                    .Select(a => new FilterableWithID(a.AnimeSeriesID, a.AnimeGroupID, a.ToFilterable(movieDBMappings), a.ToFilterableUserInfo(userID.Value))),
-                true => series ??= _series.GetAll().AsParallel().Where(a => user?.AllowedSeries(a) ?? true)
-                    .Select(a => new FilterableWithID(a.AnimeSeriesID, a.AnimeGroupID, a.ToFilterable(movieDBMappings))),
-                false when filterNeedsUser => groups ??= _groups.GetAll().AsParallel().Where(a => user?.AllowedGroup(a) ?? true)
-                    .Select(a => new FilterableWithID(0, a.AnimeGroupID, a.ToFilterable(movieDBMappings), a.ToFilterableUserInfo(userID.Value))),
-                false => groups ??= _groups.GetAll().AsParallel().Where(a => user?.AllowedGroup(a) ?? true)
-                    .Select(a => new FilterableWithID(0, a.AnimeGroupID, a.ToFilterable(movieDBMappings)))
-            };
-        });
+            var allowedGroups = _groups.GetAll().Where(a => user?.AllowedGroup(a) ?? true);
+            groups = groupsNeedUser
+                ? allowedGroups.Select(a => new FilterableWithID(0, a.AnimeGroupID, a.ToFilterable(movieDBMappings), a.ToFilterableUserInfo(userID.Value)))
+                    .ToArray()
+                : allowedGroups.Select(a => new FilterableWithID(0, a.AnimeGroupID, a.ToFilterable(movieDBMappings))).ToArray();
+        }
 
-        // Filtering
-        var filtered = filterables.SelectMany(a => a.Value.Select(filterable => (Filter: a.Key, FilterableWithID: filterable))).Where(a =>
-            (a.Filter.FilterType & GroupFilterType.Directory) == 0 && (a.Filter.Expression?.Evaluate(a.FilterableWithID.Filterable, a.FilterableWithID.UserInfo) ?? true));
+        var filterableMap = filters.Where(a => (a.FilterType & GroupFilterType.Directory) == 0)
+            .ToDictionary(filter => filter, filter => filter.ApplyAtSeriesLevel switch { true => series, false => groups });
 
-        // ordering
-        var grouped = filtered.GroupBy(a => a.Filter).ToDictionary(a => a.Key, f =>
+        // Filtering
+        var results = new Dictionary<FilterPreset, IEnumerable<IGrouping<int, int>>>();
+        foreach (var (filter, filterables) in filterableMap.AsParallel())
         {
-            var ordered = skipSorting ? f.Select(a => a.FilterableWithID) : OrderFilterables(f.Key, f.Select(a => a.FilterableWithID));
-
+            var expression = filter.Expression;
+            var filtered = filterables.AsParallel().AsUnordered().Where(a => expression?.Evaluate(a.Filterable, a.UserInfo) ?? true).ToArray();
+            var ordered = skipSorting ? (IEnumerable<FilterableWithID>)filtered : OrderFilterables(filter, filtered);
+            
             var result = ordered.GroupBy(a => a.GroupID, a => a.SeriesID);
-            if (!f.Key.ApplyAtSeriesLevel)
-                result = result.Select(a => new Grouping(a.Key, _series.GetByGroupID(a.Key).Select(ser => ser.AnimeSeriesID).ToArray()));
+            if (!filter.ApplyAtSeriesLevel)
+                result = result.Select(a => new Grouping(a.Key, _series.GetByGroupID(a.Key).Select(ser => ser.AnimeSeriesID)));
 
-            return result;
-        });
+            results.Add(filter, result);
+        }
 
-        foreach (var filter in filters.Where(filter => !grouped.ContainsKey(filter)))
-            grouped.Add(filter, Array.Empty<IGrouping<int, int>>());
+        foreach (var filter in filters.Where(filter => !results.ContainsKey(filter)))
+            results.Add(filter, Array.Empty<IGrouping<int, int>>());
 
-        return grouped;
+        return results;
     }
 
     private static IOrderedEnumerable<FilterableWithID> OrderFilterables(FilterPreset filter, IEnumerable<FilterableWithID> filtered)
@@ -160,11 +177,11 @@ private static IOrderedEnumerable<FilterableWithID> OrderFilterables(FilterPrese
 
     private record FilterableWithID(int SeriesID, int GroupID, IFilterable Filterable, IFilterableUserInfo UserInfo=null);
 
-    private record Grouping(int GroupID, int[] SeriesIDs) : IGrouping<int, int>
+    private record Grouping(int GroupID, IEnumerable<int> SeriesIDs) : IGrouping<int, int>
     {
         public IEnumerator<int> GetEnumerator()
         {
-            return ((IEnumerable<int>)SeriesIDs).GetEnumerator();
+            return SeriesIDs.GetEnumerator();
         }
 
         IEnumerator IEnumerable.GetEnumerator()
diff --git a/Shoko.Server/Filters/FilterExtensions.cs b/Shoko.Server/Filters/FilterExtensions.cs
index bd95c4681..e5b8bb21b 100644
--- a/Shoko.Server/Filters/FilterExtensions.cs
+++ b/Shoko.Server/Filters/FilterExtensions.cs
@@ -8,7 +8,6 @@
 using Shoko.Server.Models;
 using Shoko.Server.Providers.AniDB;
 using Shoko.Server.Repositories;
-using Shoko.Server.Utilities;
 using AnimeType = Shoko.Models.Enums.AnimeType;
 
 namespace Shoko.Server.Filters;
@@ -27,7 +26,7 @@ public static Filterable ToFilterable(this SVR_AnimeSeries series, ILookup<int,
             AirDateDelegate = () => series.GetAnime()?.AirDate,
             MissingEpisodesDelegate = () => series.MissingEpisodeCount,
             MissingEpisodesCollectingDelegate = () => series.MissingEpisodeCountGroups,
-            TagsDelegate = () => series.GetAnime()?.GetAllTags() ?? new HashSet<string>(),
+            TagsDelegate = () => series.GetAnime()?.GetTags().Select(a => a.TagName).ToHashSet() ?? new HashSet<string>(),
             CustomTagsDelegate =
                 () => series.GetAnime()?.GetCustomTagsForAnime().Select(a => a.TagName).ToHashSet(StringComparer.InvariantCultureIgnoreCase) ??
                       new HashSet<string>(),
diff --git a/Shoko.Server/Filters/Filterable.cs b/Shoko.Server/Filters/Filterable.cs
index c1586be66..1f0a9a54b 100644
--- a/Shoko.Server/Filters/Filterable.cs
+++ b/Shoko.Server/Filters/Filterable.cs
@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Threading;
 using Shoko.Models.Enums;
 using Shoko.Server.Filters.Interfaces;
 
@@ -46,224 +45,224 @@ public class Filterable : IFilterable
 
     public Func<string> NameDelegate
     {
-        init => _name = new Lazy<string>(value, LazyThreadSafetyMode.None);
+        init => _name = new Lazy<string>(value);
     }
 
     public string SortingName => _sortingName.Value;
 
     public Func<string> SortingNameDelegate
     {
-        init => _sortingName = new Lazy<string>(value, LazyThreadSafetyMode.None);
+        init => _sortingName = new Lazy<string>(value);
     }
 
     public int SeriesCount => _seriesCount.Value;
 
     public Func<int> SeriesCountDelegate
     {
-        init => _seriesCount = new Lazy<int>(value, LazyThreadSafetyMode.None);
+        init => _seriesCount = new Lazy<int>(value);
     }
 
     public int MissingEpisodes => _missingEpisodes.Value;
 
     public Func<int> MissingEpisodesDelegate
     {
-        init => _missingEpisodes = new Lazy<int>(value, LazyThreadSafetyMode.None);
+        init => _missingEpisodes = new Lazy<int>(value);
     }
 
     public int MissingEpisodesCollecting => _missingEpisodesCollecting.Value;
 
     public Func<int> MissingEpisodesCollectingDelegate
     {
-        init => _missingEpisodesCollecting = new Lazy<int>(value, LazyThreadSafetyMode.None);
+        init => _missingEpisodesCollecting = new Lazy<int>(value);
     }
 
     public IReadOnlySet<string> Tags => _tags.Value;
 
     public Func<IReadOnlySet<string>> TagsDelegate
     {
-        init => _tags = new Lazy<IReadOnlySet<string>>(value, LazyThreadSafetyMode.None);
+        init => _tags = new Lazy<IReadOnlySet<string>>(value);
     }
 
     public IReadOnlySet<string> CustomTags => _customTags.Value;
 
     public Func<IReadOnlySet<string>> CustomTagsDelegate
     {
-        init => _customTags = new Lazy<IReadOnlySet<string>>(value, LazyThreadSafetyMode.None);
+        init => _customTags = new Lazy<IReadOnlySet<string>>(value);
     }
 
     public IReadOnlySet<int> Years => _years.Value;
 
     public Func<IReadOnlySet<int>> YearsDelegate
     {
-        init => _years = new Lazy<IReadOnlySet<int>>(value, LazyThreadSafetyMode.None);
+        init => _years = new Lazy<IReadOnlySet<int>>(value);
     }
 
     public IReadOnlySet<(int year, AnimeSeason season)> Seasons => _seasons.Value;
 
     public Func<IReadOnlySet<(int year, AnimeSeason season)>> SeasonsDelegate
     {
-        init => _seasons = new Lazy<IReadOnlySet<(int year, AnimeSeason season)>>(value, LazyThreadSafetyMode.None);
+        init => _seasons = new Lazy<IReadOnlySet<(int year, AnimeSeason season)>>(value);
     }
 
     public bool HasTvDBLink => _hasTvDBLink.Value;
 
     public Func<bool> HasTvDBLinkDelegate
     {
-        init => _hasTvDBLink = new Lazy<bool>(value, LazyThreadSafetyMode.None);
+        init => _hasTvDBLink = new Lazy<bool>(value);
     }
 
     public bool HasMissingTvDbLink => _hasMissingTvDBLink.Value;
 
     public Func<bool> HasMissingTvDbLinkDelegate
     {
-        init => _hasMissingTvDBLink = new Lazy<bool>(value, LazyThreadSafetyMode.None);
+        init => _hasMissingTvDBLink = new Lazy<bool>(value);
     }
 
     public bool HasTMDbLink => _hasTMDbLink.Value;
 
     public Func<bool> HasTMDbLinkDelegate
     {
-        init => _hasTMDbLink = new Lazy<bool>(value, LazyThreadSafetyMode.None);
+        init => _hasTMDbLink = new Lazy<bool>(value);
     }
 
     public bool HasMissingTMDbLink => _hasMissingTMDbLink.Value;
 
     public Func<bool> HasMissingTMDbLinkDelegate
     {
-        init => _hasMissingTMDbLink = new Lazy<bool>(value, LazyThreadSafetyMode.None);
+        init => _hasMissingTMDbLink = new Lazy<bool>(value);
     }
 
     public bool HasTraktLink => _hasTraktLink.Value;
 
     public Func<bool> HasTraktLinkDelegate
     {
-        init => _hasTraktLink = new Lazy<bool>(value, LazyThreadSafetyMode.None);
+        init => _hasTraktLink = new Lazy<bool>(value);
     }
 
     public bool HasMissingTraktLink => _hasMissingTraktLink.Value;
 
     public Func<bool> HasMissingTraktLinkDelegate
     {
-        init => _hasMissingTraktLink = new Lazy<bool>(value, LazyThreadSafetyMode.None);
+        init => _hasMissingTraktLink = new Lazy<bool>(value);
     }
 
     public bool IsFinished => _isFinished.Value;
 
     public Func<bool> IsFinishedDelegate
     {
-        init => _isFinished = new Lazy<bool>(value, LazyThreadSafetyMode.None);
+        init => _isFinished = new Lazy<bool>(value);
     }
 
     public DateTime? AirDate => _airDate.Value;
 
     public Func<DateTime?> AirDateDelegate
     {
-        init => _airDate = new Lazy<DateTime?>(value, LazyThreadSafetyMode.None);
+        init => _airDate = new Lazy<DateTime?>(value);
     }
 
     public DateTime? LastAirDate => _lastAirDate.Value;
 
     public Func<DateTime?> LastAirDateDelegate
     {
-        init => _lastAirDate = new Lazy<DateTime?>(value, LazyThreadSafetyMode.None);
+        init => _lastAirDate = new Lazy<DateTime?>(value);
     }
 
     public DateTime AddedDate => _addedDate.Value;
 
     public Func<DateTime> AddedDateDelegate
     {
-        init => _addedDate = new Lazy<DateTime>(value, LazyThreadSafetyMode.None);
+        init => _addedDate = new Lazy<DateTime>(value);
     }
 
     public DateTime LastAddedDate => _lastAddedDate.Value;
 
     public Func<DateTime> LastAddedDateDelegate
     {
-        init => _lastAddedDate = new Lazy<DateTime>(value, LazyThreadSafetyMode.None);
+        init => _lastAddedDate = new Lazy<DateTime>(value);
     }
 
     public int EpisodeCount => _episodeCount.Value;
 
     public Func<int> EpisodeCountDelegate
     {
-        init => _episodeCount = new Lazy<int>(value, LazyThreadSafetyMode.None);
+        init => _episodeCount = new Lazy<int>(value);
     }
 
     public int TotalEpisodeCount => _totalEpisodeCount.Value;
 
     public Func<int> TotalEpisodeCountDelegate
     {
-        init => _totalEpisodeCount = new Lazy<int>(value, LazyThreadSafetyMode.None);
+        init => _totalEpisodeCount = new Lazy<int>(value);
     }
 
     public decimal LowestAniDBRating => _lowestAniDBRating.Value;
 
     public Func<decimal> LowestAniDBRatingDelegate
     {
-        init => _lowestAniDBRating = new Lazy<decimal>(value, LazyThreadSafetyMode.None);
+        init => _lowestAniDBRating = new Lazy<decimal>(value);
     }
 
     public decimal HighestAniDBRating => _highestAniDBRating.Value;
 
     public Func<decimal> HighestAniDBRatingDelegate
     {
-        init => _highestAniDBRating = new Lazy<decimal>(value, LazyThreadSafetyMode.None);
+        init => _highestAniDBRating = new Lazy<decimal>(value);
     }
 
     public decimal AverageAniDBRating => _averageAniDBRating.Value;
 
     public Func<decimal> AverageAniDBRatingDelegate
     {
-        init => _averageAniDBRating = new Lazy<decimal>(value, LazyThreadSafetyMode.None);
+        init => _averageAniDBRating = new Lazy<decimal>(value);
     }
 
     public IReadOnlySet<string> VideoSources => _videoSources.Value;
 
     public Func<IReadOnlySet<string>> VideoSourcesDelegate
     {
-        init => _videoSources = new Lazy<IReadOnlySet<string>>(value, LazyThreadSafetyMode.None);
+        init => _videoSources = new Lazy<IReadOnlySet<string>>(value);
     }
 
     public IReadOnlySet<string> SharedVideoSources => _sharedVideoSources.Value;
 
     public Func<IReadOnlySet<string>> SharedVideoSourcesDelegate
     {
-        init => _sharedVideoSources = new Lazy<IReadOnlySet<string>>(value, LazyThreadSafetyMode.None);
+        init => _sharedVideoSources = new Lazy<IReadOnlySet<string>>(value);
     }
 
     public IReadOnlySet<string> AnimeTypes => _animeTypes.Value;
 
     public Func<IReadOnlySet<string>> AnimeTypesDelegate
     {
-        init => _animeTypes = new Lazy<IReadOnlySet<string>>(value, LazyThreadSafetyMode.None);
+        init => _animeTypes = new Lazy<IReadOnlySet<string>>(value);
     }
 
     public IReadOnlySet<string> AudioLanguages => _audioLanguages.Value;
 
     public Func<IReadOnlySet<string>> AudioLanguagesDelegate
     {
-        init => _audioLanguages = new Lazy<IReadOnlySet<string>>(value, LazyThreadSafetyMode.None);
+        init => _audioLanguages = new Lazy<IReadOnlySet<string>>(value);
     }
 
     public IReadOnlySet<string> SharedAudioLanguages => _sharedAudioLanguages.Value;
 
     public Func<IReadOnlySet<string>> SharedAudioLanguagesDelegate
     {
-        init => _sharedAudioLanguages = new Lazy<IReadOnlySet<string>>(value, LazyThreadSafetyMode.None);
+        init => _sharedAudioLanguages = new Lazy<IReadOnlySet<string>>(value);
     }
 
     public IReadOnlySet<string> SubtitleLanguages => _subtitleLanguages.Value;
 
     public Func<IReadOnlySet<string>> SubtitleLanguagesDelegate
     {
-        init => _subtitleLanguages = new Lazy<IReadOnlySet<string>>(value, LazyThreadSafetyMode.None);
+        init => _subtitleLanguages = new Lazy<IReadOnlySet<string>>(value);
     }
 
     public IReadOnlySet<string> SharedSubtitleLanguages => _sharedSubtitleLanguages.Value;
 
     public Func<IReadOnlySet<string>> SharedSubtitleLanguagesDelegate
     {
-        init => _sharedSubtitleLanguages = new Lazy<IReadOnlySet<string>>(value, LazyThreadSafetyMode.None);
+        init => _sharedSubtitleLanguages = new Lazy<IReadOnlySet<string>>(value);
     }
 
     public IReadOnlySet<string> Resolutions => _resolutions.Value;
@@ -271,7 +270,7 @@ public Func<IReadOnlySet<string>> ResolutionsDelegate
     {
         init
         {
-            _resolutions = new Lazy<IReadOnlySet<string>>(value, LazyThreadSafetyMode.None);
+            _resolutions = new Lazy<IReadOnlySet<string>>(value);
         }
     }
 }