Github url


by ramda

ramda /ramda

:ram: Practical functional Javascript

19.3K Stars 1.2K Forks Last release: 13 days ago (v0.27.1) MIT License 2.9K Commits 52 Releases

Available items

No Items, yet!

The developer of this repository has not created any items for sale yet. Need a bug fixed? Help with integration? A different license? Create a request here:


A practical functional library for JavaScript programmers.

Build StatusTest Coveragenpm moduledependenciesGitter

Why Ramda?

There are already several excellent libraries with a functional flavor. Typically, they are meant to be general-purpose toolkits, suitable for working in multiple paradigms. Ramda has a more focused goal. We wanted a library designed specifically for a functional programming style, one that makes it easy to create functional pipelines, one that never mutates user data.

What's Different?

The primary distinguishing features of Ramda are:

  • Ramda emphasizes a purer functional style. Immutability and side-effect free functions are at the heart of its design philosophy. This can help you get the job done with simple, elegant code.

  • Ramda functions are automatically curried. This allows you to easily build up new functions from old ones simply by not supplying the final parameters.

  • The parameters to Ramda functions are arranged to make it convenient for currying. The data to be operated on is generally supplied last.

The last two points together make it very easy to build functions as sequences of simpler functions, each of which transforms the data and passes it along to the next. Ramda is designed to support this style of coding.



Using Ramda should feel much like just using JavaScript. It is practical, functional JavaScript. We're not introducing lambda expressions in strings, we're not borrowing consed lists, we're not porting over all of the Clojure functions.

Our basic data structures are plain JavaScript objects, and our usual collections are JavaScript arrays. We also keep other native features of JavaScript, such as functions as objects with properties.

Functional programming is in good part about immutable objects and side-effect free functions. While Ramda does not enforce this, it enables such style to be as frictionless as possible.

We aim for an implementation both clean and elegant, but the API is king. We sacrifice a great deal of implementation elegance for even a slightly cleaner API.

Last but not least, Ramda strives for performance. A reliable and quick implementation wins over any notions of functional purity.


To use with node:

$ npm install ramda

Then in the console:

const R = require('ramda');

To use directly in Deno:

javascript import \* as R from "";

To use directly in the browser:

<script src="path/to/yourCopyOf/ramda.js"></script>

or the minified version:

<script src="path/to/yourCopyOf/ramda.min.js"></script>

or from a CDN, either cdnjs:

<script src="//"></script>

or one of the below links from jsDelivr:

<script src="//[email protected]/dist/ramda.min.js"></script><script src="//[email protected]/dist/ramda.min.js"></script><script src="//[email protected]/dist/ramda.min.js"></script>

(note that using


is taking a significant risk that ramda API changes could break your code.)

These script tags add the variable


on the browser's global scope.

Or you can inject ramda into virtually any unsuspecting website using the bookmarklet.

Note for versions > 0.25Ramda versions > 0.25 don't have a default export. So instead of

import R from 'ramda';

, one has to use

import \* as R from 'ramda';

Or better yet, import only the required functions via

import { functionName } from 'ramda';


npm run build





directories and updates both dist/ramda.js and dist/ramda.min.js

Partial Builds

It is possible to build Ramda with a subset of the functionality to reduce its file size. Ramda's build system supports this with command line flags. For example if you're using




, and


you can create a partial build with:

npm run --silent partial-build compose reduce filter \> dist/ramda.custom.js

This requires having Node/io.js installed and ramda's dependencies installed (just use

npm install

before running partial build).

Install specific functions

Install individual functions with bit, npm and yarn without installing the whole library.


Please review the API documentation.

Also available is our Cookbook of functions built from Ramda that you may find useful.

The Name

Ok, so we like sheep. That's all. It's a short name, not already taken. It could as easily have been


, but then we would be forced to say eweda lamb!, and no one wants that. For non-English speakers, lambs are baby sheep, ewes are female sheep, and rams are male sheep. So perhaps ramda is a grown-up lambda... but probably not.

Running The Test Suite


To run the test suite from the console, you need to have



npm install -g mocha

Then from the root of the project, you can just call


Alternately, if you've installed the dependencies, via:

npm install

then you can run the tests (and get detailed output) by running:

npm test


You can use testem to test across different browsers (or even headlessly), with livereloading of tests. Install testem (

npm install -g testem

) and run


. Open the link provided in your browser and you will see the results in your terminal.

If you have PhantomJS installed, you can run

testem -l phantomjs

to run the tests completely headlessly.




and up, import the whole library or pick ES modules directly from the library:

import \* as R from 'ramda' const {identity} = R, [1, 2, 3])

Destructuring imports from ramda does not necessarily prevent importing the entire library. You can manually cherry-pick methods like the following, which would only grab the parts necessary for


to work:

import identity from 'ramda/src/identity' identity()

Manually cherry picking methods is cumbersome, however. Most bundlers like Webpack and Rollup offer tree-shaking as a way to drop unused Ramda code and reduce bundle size, but their performance varies, discussed here. Here is a summary of the optimal setup based on what technology you are using:

  1. Webpack + Babel - use [
    ]( to automatically cherry pick methods. Discussion here, example here
  2. Webpack only - use
    plugin for treeshaking along with the
    . Discussion here, with an example setup here
  3. Rollup - does a fine job properly treeshaking, no special work needed; example here




Thanks to J. C. Phillipps for the Ramda logo. Ramda logo artwork © 2014 J. C. Phillipps. Licensed Creative Commons CC BY-NC-SA 3.0.

We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.