High-performance LINQ-like extension methods for arrays, Span<T>, and List<T> with SIMD and parallel optimizations.
LinqFaster is a high-performance library that provides LINQ-like extension methods optimized for arrays, Span<T>, and List<T> collections. It solves performance bottlenecks in .NET applications by offering faster operations with reduced memory allocations, especially for small LINQ operations that immediately call ToArray() or ToList().
.NET developers working with performance-sensitive applications, particularly those using arrays and lists extensively and needing to minimize GC pressure and execution time.
Developers choose LinqFaster for its significant speed improvements over standard LINQ, SIMD and parallel optimizations, and memory-efficient operations that reduce allocations and improve cache locality.
Linq-like extension functions for Arrays, Span<T>, and List<T> that are faster and allocate less.
Open-Awesome is built by the community, for the community. Submit a project, suggest an awesome list, or help improve the catalog on GitHub.
Benchmarks show up to 10x faster execution and zero allocations for operations like Sum and Min compared to standard LINQ, especially for small operations that materialize immediately with ToArray() or ToList().
Provides SIMD-accelerated and multithreaded methods for arrays, leveraging hardware vectorization to significantly speed up aggregate operations like Sum and Max on large datasets.
Reduces GC churn with in-place operations (e.g., SelectInPlace) and combined single-pass methods (e.g., WhereSelect), improving cache locality and application responsiveness.
Extension methods mirror LINQ names with an extra character (e.g., SelectF), making it straightforward to replace specific calls in existing code without a steep learning curve.
Imperative evaluation means chaining methods can lead to multiple iterations and allocations, negating performance benefits unless combined operations like WhereSelect are used, requiring code restructuring.
OrderBy methods are not a stable sort, breaking compatibility with applications relying on LINQ's stable sorting, and floating-point operations may yield slightly different results due to non-commutative math.
As .NET 9 incorporates similar optimizations into native LINQ, LinqFaster's value is diminished for new projects, potentially making it an unnecessary dependency.
SIMD and parallel methods require careful batch size tuning and may not always outperform scalar versions depending on hardware and dataset size, adding complexity without guaranteed gains.