You can install ESLint using npm:

You should then set up a configuration file:

After that, you can run ESLint on any file or directory like this:

The first step to sending a pull request is to create a new branch in your ESLint fork. Give the branch a descriptive name that describes what it is you're fixing, such as:

You should do all of your development for the issue in this branch.

Make the changes to the code and tests, following the [code conventions](../code-conventions.md) as you go. Once you have finished, commit the changes to your branch:

All ESLint projects follow [Conventional Commits](https://www.conventionalcommits.org/) for our commit messages. Here's an example commit message:

If your commit message is in the incorrect format, you'll be asked to update it. You can do so via:

This will open up your editor so you can make changes. After that, you'll need to do a forced push to your branch:

If we ask you to make code changes, there's no need to close the pull request and create a new one. Just go back to the branch on your fork and make your changes. Then, when you're ready, you can add your changes into the branch:

When updating the code, it's usually better to add additional commits to your branch rather than amending the original commit, because reviewers can easily tell which changes were made in response to a particular review. When we merge pull requests, we will squash all the commits from your branch into a single commit on the `main` branch.

If your code is out-of-date, we might ask you to rebase. That means we want you to apply your changes on top of the latest upstream code. Make sure you have set up a [development environment](../development-environment.md) and then you can rebase using these commands:

You might find that there are merge conflicts when you attempt to rebase. Please [resolve the conflicts](https://help.github.com/articles/resolving-merge-conflicts-after-a-git-rebase/) and then do a forced push to your branch:

Once you've cloned the repository, run `npm install` to get all the necessary dependencies:

You must be connected to the Internet for this step to work. You'll see a lot of utilities being downloaded.

You should then set up a configuration file, and the easiest way to do that is:

**Note:** `npm init @eslint/config` assumes you have a `package.json` file already. If you don't, make sure to run `npm init` or `yarn init` beforehand.

After that, you can run ESLint on any file or directory like this:

It is also possible to install ESLint globally rather than locally (using `npm install eslint --global`). However, this is not recommended, and any plugins or shareable configs that you use must be installed locally in either case.

To install Polyjuice:

Polyjuice works with JSON configuration files, so if you're using a JavaScript or YAML JSCS configuration file, you should first convert it into a JSON configuration file.

To convert your configuration file, pass in the location of your `.jscs.json` file using the `--jscs` flag:

This creates a `.eslintrc.json` with the equivalent rules from `.jscsrc.json`.

If you have multiple `.jscsrc.json` files, you can pass them all and Polyjuice will combine them into one `.eslintrc.json` file:

**Note:** Polyjuice does a good job of creating a reasonable ESLint configuration from your JSCS configuration, but it may not be 100%. You may still see different warnings than you saw with JSCS, and so you may need to further modify your configuration after using Polyjuice. This is especially true if you're using inline comments to enable/disable certain rules in JSCS (you'll need to manually convert those to use ESLint-style comments instead, see "Disabling Rules Inline" later in this page).

If you don't want to convert your JSCS configuration directly into an ESLint configuration, then you can use ESLint's built-in wizard to get you started. Just run:

You'll be guided through a series of questions that will help you setup a basic configuration file to get you started.

In order to get the same functionality in ESLint, you would first need to install the `eslint-config-airbnb` shareable config package:

And then you would modify your configuration file like this:

JSCS uses the `--fix` option to apply automatic fixes to code:

ESLint has the same option:

The JSCS `--auto-configure` option created a configuration based on what it found in a given file:

In ESLint, there's a similar option when you use `--init`. Just select "Inspect your JavaScript file(s)":

? How would you like to configure ESLint? (Use arrow keys)

> Answer questions about your style

Use a popular style guide

JSCS allows you to specify a configuration file to use on the command line using either `--config` or `-c`, such as:

Both flags are also supported by ESLint:

In JSCS, you can pipe code in like this:

In ESLint, you can also pipe in code, but you need to use the `--stdin` flag:

Previous versions of ESLint silently ignored any nonexistent files and globs provided on the command line:

Many users found this behavior confusing, because if they made a typo in a filename, ESLint would appear to lint that file successfully while actually not linting anything.