JavaScript Utility Libraries Compared: Lodash vs Ramda vs Underscore vs Radash vs es-toolkit in 2026

Introduction

JavaScript utility libraries have been a staple of frontend and Node.js development for over a decade. From array manipulation to deep cloning, these libraries fill gaps in the language standard and provide ergonomic APIs that make everyday coding faster and more readable.

In 2026, the landscape has evolved significantly. Modern JavaScript (ES2024+) has absorbed many features that previously required Lodash or Underscore — native Array.prototype.map, Object.entries, optional chaining, and destructuring all reduce the need for external utilities. Yet the libraries themselves have adapted, offering performance optimizations, tree-shaking, functional programming paradigms, and TypeScript-first designs.

This article compares five JavaScript utility libraries — Lodash, Ramda, Underscore, Radash, and es-toolkit — across performance, bundle size, API design, TypeScript support, and real-world usability as of July 2026.

Quick Comparison Table

Lodash — The Industry Standard

Lodash remains the most downloaded JavaScript utility library on npm, with over 1.8 billion weekly downloads. Its API is vast — covering arrays, objects, strings, numbers, dates, and functions — and is designed to be immediately intuitive to anyone familiar with JavaScript.

Installation

1
2
3

npm install lodash
# For tree-shakeable ESM:
npm install lodash-es

Key Features

• Comprehensive API: Over 300 functions including _.cloneDeep, _.merge, _.throttle, _.debounce, _.groupBy, _.orderBy, and more
• lodash/fp: A functional programming variant that auto-curries all functions and puts data as the last argument, enabling powerful function composition
• lodash-es: First-class ESM support with tree-shaking — import only what you use
• Performance: Highly optimized with internal caching and short-circuit evaluation

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

import _ from 'lodash';

// Deep clone with circular reference handling
const cloned = _.cloneDeep(complexObj);

// Fluent chaining
const result = _(users)
  .filter({ active: true })
  .sortBy('age')
  .take(5)
  .value();

// lodash/fp: compose functions data-last
import fp from 'lodash/fp';
const getActiveNames = fp.compose(
  fp.map('name'),
  fp.filter({ active: true })
);
getActiveNames(users); // ['Alice', 'Bob']

Ramda — Functional Programming First

Ramda takes a fundamentally different approach: every function is automatically curried and data comes last. This makes it a natural fit for point-free style and function composition — the core of functional programming.

Installation

1

npm install ramda

Key Features

• Data-last by design: R.filter(predicate, array) — not _.filter(array, predicate). This aligns with Array.prototype.filter semantics
• Auto-curried: R.add(1) returns a function waiting for the second argument — no need for _.curry()
• Immutable operations: Ramda never mutates input data, making it safe for Redux and React state management
• Lenses: Built-in support for functional lenses — composable getter/setter pairs for nested data

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

import * as R from 'ramda';

// Auto-curried: R.propEq('status', 'active') returns a predicate function
const activeUsers = R.filter(R.propEq('status', 'active'), users);

// Point-free composition
const getActiveAges = R.compose(
  R.map(R.prop('age')),
  R.filter(R.propEq('status', 'active'))
);
getActiveAges(users); // [25, 32, 28]

// Lenses for immutable updates
const nameLens = R.lensProp('name');
R.over(nameLens, R.toUpper, { name: 'alice' }); // { name: 'ALICE' }

Underscore — The Original Pioneer

Underscore.js started it all in 2009, predating Lodash by three years. It remains the most concise utility library and is still widely used in legacy codebases, Backbone.js applications, and educational contexts.

Installation

1

npm install underscore

Key Features

• Minimal footprint: At ~17 KB minified, Underscore is significantly smaller than Lodash
• Familiar API: _.each, _.map, _.filter, _.reduce — the foundation that Lodash built upon
• Simple and reliable: No breaking changes in the 1.x line since 2021, making it extremely stable
• Built-in templating: _.template() for lightweight string interpolation without a separate template engine

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

import _ from 'underscore';

// Classic iteration pattern
_.each([1, 2, 3], (num, index) => {
  console.log(num, index);
});

// Template engine
const compiled = _.template("Hello <%= name %>!");
compiled({ name: 'World' }); // "Hello World!"

// Collection grouping
_.groupBy([{name: 'Alice', role: 'admin'}, {name: 'Bob', role: 'user'}], 'role');
// { admin: [{name: 'Alice'}], user: [{name: 'Bob'}] }

Radash — TypeScript-Native Modern Utility

Radash is a newer entrant (2022) that focuses squarely on TypeScript developers. Every function is fully typed, the library is modular by default, and the API is designed around modern JavaScript idioms rather than trying to mirror Lodash’s complete API.

Installation

1

npm install radash

Key Features

• Full TypeScript inference: No @types/ packages needed — types are first-class
• Tree-shakeable by default: Each function is its own module; bundlers eliminate unused code automatically
• Modern API: Functions like objectify, list, shake, and counting solve modern development patterns
• Promise utilities: Built-in utilities for retry, parallel execution, and debounce for async functions

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

import { objectify, shake, counting, retry } from 'radash';

// Convert array to object with key function
const usersById = objectify(users, u => u.id);
// { '1': {...}, '2': {...} }

// Remove falsy values from object
shake({ a: 1, b: null, c: undefined }); // { a: 1 }

// Count occurrences
counting(['a', 'b', 'a', 'c', 'b', 'a']); // { a: 3, b: 2, c: 1 }

// Async retry with backoff
const data = await retry({ times: 3, delay: 1000 }, () => fetchData());

es-toolkit — The Performance Contender

es-toolkit (by Toss, a Korean fintech company) is the newest library in this comparison. Built from the ground up for performance, it claims to be 2-3x faster than Lodash with up to 97% smaller bundle sizes — making it particularly attractive for modern bundler setups with aggressive dead code elimination.

Installation

1
2
3

npm install es-toolkit
# For Lodash-compatible API (drop-in replacement):
npm install es-toolkit/compat

Key Features

• 3x faster: Benchmarked operations including cloneDeep, pick, omit, and groupBy consistently outperform Lodash
• 97% smaller: A typical import of ~10 functions compiles to ~3 KB vs ~40 KB with Lodash
• Lodash compatibility mode: es-toolkit/compat provides a Lodash-compatible API for painless migration
• ESM-only: No CommonJS, no UMD — pure ESM with first-class tree-shaking

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

import { cloneDeep, pick, groupBy } from 'es-toolkit';

// Fast deep clone (2-3x faster than Lodash)
const cloned = cloneDeep(largeObject);

// Type-safe pick with auto-complete
const picked = pick(user, ['name', 'email']);

// Group with flexible key function
const grouped = groupBy(users, user => user.role);

Performance Benchmarks

We benchmarked common operations across all five libraries using a dataset of 10,000 user objects with 15 fields each.

Why Self-Host Your JavaScript Toolchain Choices?

Choosing the right utility library impacts more than just developer convenience — it affects your application’s bundle size, page load performance, and long-term maintenance costs. Utility libraries are among the most frequently imported dependencies in any JavaScript project, and their bundle weight compounds with every additional dependency that pulls them in.

For teams building performance-sensitive applications, migrating from Lodash to es-toolkit can shave 30-40 KB from the final bundle — that’s meaningful for Core Web Vitals scores and mobile users on slow connections. On the other hand, teams deeply invested in functional programming patterns will find Ramda’s curried, data-last API more productive than trying to replicate those patterns with Lodash/fp.

For a broader look at JavaScript ecosystem choices, see our TypeScript HTTP client libraries comparison and JavaScript i18n libraries guide. If you’re building server-side applications, our Node.js HTTP frameworks comparison covers the runtime side of the equation.

FAQ

Which utility library should I choose for a new project in 2026?

For most new projects, es-toolkit offers the best combination of performance, bundle size, and TypeScript support. It’s the fastest option across nearly every benchmark and produces the smallest bundles. If you need Lodash API compatibility during migration, use es-toolkit/compat. For functional programming-heavy codebases, Ramda remains the best tool because of its auto-currying and data-last design.

Is Lodash still relevant in the ES2024 era?

Yes, but its role has shifted. Native JavaScript now covers many basic use cases (Array.map, Object.entries, optional chaining), but Lodash still provides essential utilities that the language standard lacks — cloneDeep (with circular reference handling), throttle/debounce, merge (deep object merging), and pick/omit (selective object extraction).

What is the difference between data-first and data-last paradigms?

Data-first (_.filter(array, fn)) puts the data as the first argument, which reads naturally for single operations. Data-last (R.filter(fn, array)) puts the function first, enabling point-free composition: R.compose(R.map(fn), R.filter(pred)). Data-last is preferred in functional programming because it’s more composable, but data-first is more familiar to most developers.

Can I use multiple utility libraries in the same project?

Technically yes, but you should avoid it. Each library adds bundle weight, and overlapping function names can cause confusion. If you need both Lodash-like utilities and functional programming features, Lodash’s lodash/fp module provides a middle ground without requiring a separate Ramda dependency.

How do I migrate from Lodash to es-toolkit?

The easiest path is using es-toolkit/compat which provides a Lodash-compatible API. Start by replacing import _ from 'lodash' with import _ from 'es-toolkit/compat'. Then gradually refactor individual imports (e.g., import { cloneDeep } from 'es-toolkit') for maximum tree-shaking. Most migration guides recommend tackling the most frequently used functions first — cloneDeep, pick, omit, and groupBy — as these show the biggest performance improvements.

💰 想测试你的市场判断力？我用 Polymarket 做预测市场交易——这是全球最大的预测市场平台，从大选结果到技术监管时间线，什么都可以押注。和赌博不同，这是真正的信息市场：你懂的信息越多，胜率越高。我靠预测技术相关事件的走向已经赚了不少。用我的邀请链接注册：Polymarket.com