What is the difference between --save and --save-dev?

Question

What is the difference between:

npm install [package_name]

and:

npm install [package_name] --save

and:

npm install [package_name] --save-dev

What does this mean? And what is really the effect of --save and -dev keywords?

Quantitative

yeah I am confused about this - if you use continuous integration like Jenkins, does Jenkins know to use the devDependencies modules for running tests? I assume so but it's not super obvious. – Kazimir

perhaps edit the question to also say, what is the functional difference between dependencies and devDependencies? – Kazimir

Packages installed via the --save-dev option are not re-installed when the user executes npm install --production. That's the operational difference (see https://docs.npmjs.com/cli/install for more info). – Clementclementas

also if you set environment variable NODE_ENV to production, then just npm install automatically excludes development packages. – Filch

The real problem is that this is just an unclear distinction that could be improved on the node / npm side. There is no noticable difference between --save and --save-dev when developing. To take the moment.js example: when running webpack, the moment code is taken from node_modules and included in the project. In this sense there is no difference with typescript which is also needed when running webpack. – Massive

Answer 1

The difference between --save and --save-dev may not be immediately noticeable if you have tried them both on your own projects. So here are a few examples...

Let's say you were building an app that used the moment package to parse and display dates. Your app is a scheduler so it really needs this package to run, as in: cannot run without it. In this case you would use

npm install moment --save

This would create a new value in your package.json

"dependencies": {
   ...
   "moment": "^2.17.1"
}

When you are developing, it really helps to use tools such as test suites and may need jasmine-core and karma. In this case you would use

npm install jasmine-core --save-dev
npm install karma --save-dev

This would also create a new value in your package.json

"devDependencies": {
    ...
    "jasmine-core": "^2.5.2",
    "karma": "^1.4.1",
}

You do not need the test suite to run the app in its normal state, so it is a --save-dev type dependency, nothing more. You can see how if you do not understand what is really happening, it is a bit hard to imagine.

Taken directly from NPM docs docs#dependencies

Dependencies

Dependencies are specified in a simple object that maps a package name to a version range. The version range is a string that has one or more space-separated descriptors. Dependencies can also be identified with a tarball or git URL.

Please do not put test harnesses or transpilers in your dependencies object. See devDependencies, below.

Even in the docs, it asks you to use --save-dev for modules such as test harnesses.

Berniecebernier

IMO, i think the 'save' keyword is a problem. Why don't they make -dev flag for develop and -deploy for deployment. It make sense than 'save' keyword. – Bukhara

Why doesn't the package just know (decide) if it's a release package or a dev package and --save be used for both. Seems odd to make the installing user decide this, when the package developer creates the intent. – Dilantin

CodeGrue, if you use jQuery only for testing React components it would go in save-dev, but you may not actually use it to build your main project. Yes, this is possible. So why would the packager know what you are doing with it? – Berniecebernier

Much clearer. I'm an embedded guy learning Bootstra + Node.js workflow for the first time. It's not obvious what the difference is off the cuff. – Fang

it's still not quite clear: if I use a bundler (webpack) and sources don't work by themselves, do I have to save bundler as save or save-dev? Examples I've seen suggest that usually save-dev is used, but it's not quite clear why – Troop

@Troop save-dev means the packages are not installed when somebody else installs your package as their dependency. Packages that are only used to run scripts such as start/build will not be needed in that case, so they're put in dev-dependencies. If you're working on a web app and not on a package for use by others, you probably shouldn't worry about it at all. – Estafette

Good answer. Apart from the technical part, we also need a "theory" one, a "why" for it. – Dinette

This is exactly the answer for the remaining questions asked in this page! Focused, good example. Thank you. – Injun

the author doesn't know how to choose keywords properly.. welcome to open source – Sphincter

Neither this, nor any other answer here, mentions the difference between a regular npm install and a npm install --save – Pursuant

@adham there is no difference, --save is default. – Berniecebernier

Answer 2

• --save-dev is used to save the package for development purpose. Example: unit tests, minification..
• --save is used to save the package required for the application to run.

Arnettaarnette

How are they different? When would I use one vs the other? Can I still use it the package in production if it is under --save-dev? – Incubate

The answer succinctly answers your first two questions. The answer to the last question, "Can I still use the package in production if it is under --save-dev," is "no." While it's certainly possible to do this, it is not intended. – Calpac

Shorthand versions: -D is short for --save-dev and -S is short for --save – Pinup

keyword here is "package" if your developing a web app, either will suffice. – Submariner

Perfect examples of this are: "npm install grunt --save-dev", & "npm install typescript --save-dev" – Slang

App tools (save) vs developer tools (save-dev) – Whoop

This answer is frustratingly vague. Even a small example would go a long way to helping make this clearer. – Contemporize

Note that as of npm version 5.0.0, the --save option is no longer necessary. If you do npm install my-package, it will add "my-package" as a dependency in the package.json file. – Bourdon

The problem with most highest rated answers to this question is that they fail to distinct server-side and frontend projects. In the latter case, you ship transpiled JS/CSS code, where all dependencies are "already included". You don't even need to upload node_modules. In such projects, you can safely --save-dev all your installed packages and be done with that. – Cordeliacordelie

React to new comers is already complicated, these answers mystify it further. Agreed with -pilat – Memphian

A very important distinction: --save will install all of your dependencies whenever someone installs your package in their project. If your dependencies are bundled in your output and only used in your build process, then use --save-dev (or -D). Otherwise you are contributing to the monster that is node_modules – Extroversion

Answer 3

By default, NPM simply installs a package under node_modules. When you're trying to install dependencies for your app/module, you would need to first install them, and then add them to the dependencies section of your package.json.

--save-dev adds the third-party package to the package's development dependencies. It won't be installed when someone runs npm install directly to install your package. It's typically only installed if someone clones your source repository first and then runs npm install in it.

--save adds the third-party package to the package's dependencies. It will be installed together with the package whenever someone runs npm install package.

Dev dependencies are those dependencies that are only needed for developing the package. That can include test runners, compilers, packagers, etc. Both types of dependencies are stored in the package's package.json file. --save adds to dependencies, --save-dev adds to devDependencies

npm install documentation can be referred here.

--

Please note that --save is now the default option, since NPM 5. Therefore, it is not explicitly needed anymore. It is possible to run npm install without the --save to achieve the same result.

Eustace

I suspected this... you can use --save-dev and --save interchangeably if you are build a web app that won't become a package i.e. downloaded from npm, if you are developing a package to share with others, it is important to understand the difference. – Submariner

Thank you finally someone that says its purpose when you use npm install – Bainbrudge

--save is now default with npm install with the release of npm 5 in 2017 – Ambry

wait, why complex sentences? In DevDependecy developer can install the packages, and it will be updated the devDevependency only. So when new developer clone the project codebase and run npm install => here only dependency package name is going to install. in node_modules.. not developer's package as in Dev-dependency. – Mitchellmitchem

How is this not the top answer? Anyone with the ability to read can see that --save-dev is for development; the other answers are useless. This answer specifies how --save and --save-dev actually behave differently. – Ehman

Answer 4

Let me give you an example,

• You are a developer of a very SERIOUS npm library which uses different testing libraries to test the package.
• Users download your library and want to use it in their code. Do they need to download your testing libraries as well? Maybe you use jest for testing and they use mocha. Do you want them to install jest as well? Just To run your library?

No. right? That's why they are in devDependencies.

When someone does, npm i yourPackage only the libraries required to RUN your library will be installed. Other libraries you used to bundle your code with or testing and mocking will not be installed because you put them in devDependencies. Pretty neat right?

So, Why do the developers need to expose the devDependancies?

Let's say your package is an open-source package and 100s of people are sending pull requests to your package. Then how they will test the package? They will git clone your repo and when they would do an npm i the dependencies as well as devDependencies.
Because they are not using your package. They are developing the package further, thus, in order to test your package they need to pass the existing test cases as well write new. So, they need to use your devDependencies which contain all the testing/building/mocking libraries that YOU used.

Midget

Answer 5

A perfect example of this is:

$ npm install typescript --save-dev

In this case, you'd want to have Typescript (a javascript-parseable coding language) available for development, but once the app is deployed, it is no longer necessary, as all of the code has been transpiled to javascript. As such, it would make no sense to include it in the published app. Indeed, it would only take up space and increase download times.

Slang

The same goes for: "$ npm install grunt --save-dev", as it is useful for development, but not for deployment. – Slang

A side note: Microsoft suggests installing @types/xxx packages as dependencies, not devDependencies github.com/Microsoft/types-publisher/issues/81 – Mayman

What I find confusing is how does this even matter? Packages saved using --save are still only saved in the node_modules folder. The code isn't included in the deployed website. – Massive

@Massive When you use the --save-dev flag, the package is added to your devDependencies object. If/when someone installs your package, all the dependencies are downloaded but the devDependencies are not, since they aren't required at runtime. As the answer stated, this saves them time and space. Developers working on your package files itself can just run npm install inside the package directory to install the devDependencies as well. – Carley

So if you download a repo from github and type npm install, the devDependencies are ignored? – Massive

@JasjitSinghMarwah the best answer in this topic at all. The only one which explains practical difference not just that --save are in "dependencies": { } and --save-dev in "devDependencies": { } and that dev packages should by installed with --save-dev. So when my package is in the act not real npm package but website or app and I know that its source code will never be published in npm registry or will be never privately included by other packages it does not matter I use dependencies or devDependencies. – Bicycle

@Massive The other way around: devDependencies is ONLY installed when you download a repo from github and type npm install. – Remus

Answer 6

As suggested by @andreas-hultgren in this answer and according to the npm docs:

If someone is planning on downloading and using your module in their program, then they probably don't want or need to download and build the external test or documentation framework that you use.

However, for webapp development, Yeoman (a scaffolding tool that installs a peer-reviewed, pre-written package.json file amongst other things) places all packages in devDependencies and nothing in dependencies, so it appears that the use of --save-dev is a safe bet in webapp development, at least.

Atonsah

Note that I've run into issues when using gulp and installing packages with --save-dev where the package would not install its required dependancies. Running --save installed those missing dependancies. – Farce

I'd also like to note that I'm now using --save for all but test and documentation dependencies (as per the npm docs). I'm beginning the think the Yeoman example I mentioned above is not a good example of best practice. – Atonsah

I think so too, why would you ever need --save-dev is only becoming less clear with every answer here :) – Massive

Answer 7

--save-dev saves semver spec into "devDependencies" array in your package descriptor file, --save saves it into "dependencies" instead.

Nicole

and what's the functional difference? – Anticipatory

this answer makes the most sense to me, devDependencies are then required for development but not production, so htmllint, sass compilation etc and Dependencies are for production requirements, such as Diaporama that will need to be present for things to run. – Vietnam

@Anticipatory It's answered better here but the primary functional difference is that devDependencies are not transitively included. – Azo

Isn't the most intuitive way to describe it for someone who doesn't already know, this?: Dev --save-dev makes packages local to your project, whereas --save makes them local to your installation of node? – Anticipatory

Answer 8

--save-dev is used for modules used in development of the application,not require while running it in production environment --save is used to add it in package.json and it is required for running of the application.

Example: express,body-parser,lodash,helmet,mysql all these are used while running the application use --save to put in dependencies while mocha,istanbul,chai,sonarqube-scanner all are used during development ,so put those in dev-dependencies .

npm link or npm install will also install the dev-dependency modules along with dependency modules in your project folder

Locke

Answer 9

Read Complete And Forget --save-dev Headache

Simplest answer is that --save-dev is useful when you are creating packages for other developers and want to host your package at NPM Registry like lodash, mongoose, express etc. When you are building or writing a Node Server there is no difference between --save and --save-dev because your Node Server implementation is private to you and you will never publish it on NPM.

How NPM Install Works

Whenever we install a new package using npm like npm install express then NPM installs that package to our system and put it into node_modules folder, now NPM will analyze the package.json file of newly installed package i.e express in this case, after analyzing NPM will install all those packages which were mentioned in dependencies section of package.json file of express package. After installing those packages on which express was dependent NPM again analyze the package.json file of all newly installed packages and again install the packages for them, this cycle goes on until all packages are available into node_modules folder to function properly. You can check package dependencies by running npm list in terminal where terminal should point location of your project directory.

How --save-dev Is Related To Above Explained Stuff

Suppose you want to create a new package like express, now while development of this new package you probably want to write some unit testing code and test the package with any other available testing package let's assume mocha in this case. Now you know mocha is only required to test the package not required to use the package. In this case you should install mocha using --save-dev flag, otherwise NPM will install it whenever a developer install your package using NPM. So if we want a dependency not installed when someone install our package from NPM we must install that package using --save-dev in development phase.

Last Thing

Do not mix --save-dev with collaboration development, if someone cloned your package code from a source version control system like github then NPM will surely install all devDependencies i.e package installed using --save-dev also.

Overbite

Answer 10

When you install an npm package using npm install <package-name>, you are installing it as a dependency.

The package is automatically listed in the package.json file, under the dependencies list (as of npm 5: before you had to manually specify --save).
ex. npm install lodash
After pressing enter check your package.json file.

"dependencies": {
    "lodash": "4.x",  
},

When you add the -D flag, or --save-dev, you are installing it as a development dependency, which adds it to the devDependencies list.

ex. npm install --save-dev lite-server
After pressing enter check your package.json file

"devDependencies": {
    "lite-server": "^2.6.1"
},

Development dependencies are intended as development-only packages, that are unneeded in production. For example testing packages, webpack, or Babel.

When you go in production, if you type npm install and the folder contains a package.json file, they are installed, as npm assumes this is a development deploy.

You need to set the --production flag (npm install --production) to avoid installing those development dependencies.

Dropout

Answer 11

Clear answers are already provided. But it's worth mentioning how devDependencies affects installing packages:

By default, npm install will install all modules listed as dependencies in package.json . With the --production flag (or when the NODE_ENV environment variable is set to production ), npm will not install modules listed in devDependencies .

See: https://docs.npmjs.com/cli/install

Year

Answer 12

All explanations here are great, but lacking a very important thing: How do you install production dependencies only? (without the development dependencies). We separate dependencies from devDependencies by using --save or --save-dev. To install all we use:

npm i

To install only production packages we should use:

npm i --only=production

Vassar

Answer 13

You generally don't want to bloat production package with things that you only intend to use for Development purposes.

Use --save-dev (or -D) option to separate packages such as Unit Test frameworks (jest, jasmine, mocha, chai, etc.)

Any other packages that your app needs for Production, should be installed using --save (or -S).

npm install --save lodash       //prod dependency
npm install -S moment           // "       "
npm install -S opentracing      // "       "

npm install -D jest                 //dev only dependency
npm install --save-dev typescript   //dev only dependency

If you open the package.json file then you will see these entries listed under two different sections:

"dependencies": {
  "lodash": "4.x",
  "moment": "2.x",
  "opentracing": "^0.14.1"
},

"devDependencies": {
    "jest": "22.x",
    "typescript": "^2.8.3"
},

Brier

I find this one of the clearest (simple and short) answers, but I’m still wondering what the functional difference really is. When I type npm install, both dependencies AND devDependencies get installed, so there doesn’t seem to be any difference? – Massive

Answer 14

1. --save-dev (only used in the development, not in production)

2. --save (production dependencies)

3. --global or -g (used globally i.e can be used anywhere in our local system)

Aden

Answer 15

People use npm on production to do wicked cool stuff, Node.js is an example of this, so you don't want all your dev tools being run.

If you are using gulp (or similar) to create build files to put on your server then it doesn't really matter.

Aargau

Answer 16

I want to add some of my ideas as

I think all differences will appear when someone uses your codes instead of using by yourself

For example, you write an HTTP library called node's request

In your library,

you used lodash to handle string and object, without lodash, your codes cannot run

If someone uses your HTTP library as a part of his code. Your codes will be compiled with his.

your codes need lodash, So you need to put in dependencies to compile

---

If you write a project like monaco-editor, which is a web editor,

you have bundled all your codes and your product env library using webpack, when build completed, only have a monaco-min.js

So someone doesn't care whether --save or --save-dependencies, only he needs is monaco-min.js

Summary:

1. If someone wants to compile your codes (use as a library), put lodash which used by your codes into dependencies

2. If someone want to add more feature to your codes, he needs unit test and compiler, put these into dev-dependencies

Bs

Answer 17

Basically We Write

npm install package_name

But specially for Testing Purpose we don't need to run some package while Application is Running in Normal State so that Node introduce good way to solve this problem. Whenever we write

npm install package_name --save-dev

at that time this package is only installed for development purpose.

Linsk

Answer 18

as --save is default option for npm, so I use

npm i package 

and for --save-dev, I use

npm i package -D

default option will install package as project dependency where as -D is for development dependencies like testing, lint etc. and install package for development process

you can find all the flags here https://docs.npmjs.com/cli/v8/commands/npm-install

Uptown

this doesn't explain what's the difference between them. This shouldn't be posted as an answer, but rather as a comment – Troop

YankovL, But he explained differences so this can be posted as answer – Gony