For use during development of a node.js based application.
nodemon will watch the files in the directory in which nodemon was started, and if any files change, nodemon will automatically restart your node application.
nodemon does not require any changes to your code or method of development. nodemon wraps your node application and keeps an eye on any files that have changed. Remember that nodemon is a replacement wrapper for
node, think of it as replacing the word "node" on the command line when you run your script.
Either through cloning with git or by using npm (the recommended way):
npm install -g nodemon
And nodemon will be installed globally to your system path.
You can also install nodemon as a developement dependency:
npm install --save-dev nodemon
With a local installation, nodemon will not be available in your system path. Instead, the local installation of nodemon can be run by calling it from within an npm script (such as
npm start) or using
nodemon wraps your application, so you can pass all the arguments you would normally pass to your app:
nodemon [your node app]
For CLI options, use the
Using nodemon is simple, if my application accepted a host and port as the arguments, I would start it as so:
nodemon ./server.js localhost 8080
Any output from this script is prefixed with
[nodemon], otherwise all output from your application, errors included, will be echoed out as expected.
If no script is given, nodemon will test for a
package.json file and if found, will run the file associated with the main property (ref).
You can also pass the
inspect flag to node through the command line as you would normally:
nodemon --inspect ./server.js 80
If you have a
package.json file for your app, you can omit the main script entirely and nodemon will read the
package.json for the
main property and use that value as the app.
nodemon will also search for the
scripts.start property in
package.json (as of nodemon 1.1.x).
nodemon was originally written to restart hanging processes such as web servers, but now supports apps that cleanly exit. If your script exits cleanly, nodemon will continue to monitor the directory (or directories) and restart the script if there are any changes.
Whilst nodemon is running, if you need to manually restart your application, instead of stopping and restart nodemon, you can type
rs with a carriage return, and nodemon will restart your process.
nodemon supports local and global configuration files. These are usually named
nodemon.json and can be located in the current working directory or in your home directory. An alternative local configuration file can be specified with the
--config <file> option.
The specificity is as follows, so that a command line argument will always override the config file settings:
A config file can take any of the command line arguments as JSON key values, for example:
nodemon.json file might be my global config so that I have support for ruby files and processing files, and I can run
nodemon demo.pde and nodemon will automatically know how to run the script even though out of the box support for processing scripts.
A further example of options can be seen in sample-nodemon.md
If you want to keep all your package configurations in one place, nodemon supports using
package.json for configuration.
Specify the config in the same format as you would for a config file but under
nodemonConfig in the
package.json file, for example, take the following
Note that if you specify a
--config file or provide a local
package.json config is ignored.
This section needs better documentation, but for now you can also see
nodemon --help config (also here).
Please see doc/requireable.md
nodemon can also be used to execute and monitor other programs. nodemon will read the file extension of the script being run and monitor that extension instead of .js if there's no
nodemon --exec "python -v" ./app.py
Now nodemon will run
app.py with python in verbose mode (note that if you're not passing args to the exec program, you don't need the quotes), and look for new or modified files with the
nodemon.json config file, you can define your own default executables using the
execMap property. This is particularly useful if you're working with a language that isn't supported by default by nodemon.
To add support for nodemon to know about the .pl extension (for Perl), the nodemon.json file would add:
Now running the following, nodemon will know to use
perl as the executable:
It's generally recommended to use the global
nodemon.json to add your own
execMap options. However, if there's a common default that's missing, this can be merged in to the project so that nodemon supports it by default, by changing default.js and sending a pull request.
By default nodemon monitors the current working directory. If you want to take control of that option, use the
--watch option to add specific paths:
nodemon --watch app --watch libs app/server.js
Now nodemon will only restart if there are changes in the
./libs directory. By default nodemon will traverse sub-directories, so there's no need in explicitly including sub-directories.
Don't use unix globbing to pass multiple directories, e.g
--watch ./lib/*, it won't work. You need a
--watch flag per directory watched.
By default, nodemon looks for files with the
.json extensions. If you use the
--exec option and monitor
app.py nodemon will monitor files with the extension of
.py. However, you can specify your own list with the
--ext) switch like so:
nodemon -e js,jade
Now nodemon will restart on any changes to files in the directory (or subdirectories) with the extensions .js, .jade.
By default, nodemon will only restart when a
This can be done via the command line:
nodemon --ignore lib/ --ignore tests/
Or specific files can be ignored:
nodemon --ignore lib/app.js
Patterns can also be ignored (but be sure to quote the arguments):
nodemon --ignore 'lib/*.js'
Note that by default, nodemon will ignore the
.sass-cache directories and add your ignored patterns to the list. If you want to indeed watch a directory like
node_modules, you need to override the underlying default ignore rules.
In some networked environments (such as a container running nodemon reading across a mounted drive), you will need to use the
legacyWatch: true which enables Chokidar's polling.
Via the CLI, use either
-L for short:
Though this should be a last resort as it will poll every file it can find.
In some situations, you may want to wait until a number of files have changed. The timeout before checking for new file changes is 1 second. If you're uploading a number of files and it's taking some number of seconds, this could cause your app to restart multiple times unnecessarily.
To add an extra throttle, or delay restarting, use the
nodemon --delay 10 server.js
For more precision, milliseconds can be specified. Either as a float:
nodemon --delay 2.5 server.js
Or using the time specifier (ms):
nodemon --delay 2500ms server.js
The delay figure is number of seconds (or milliseconds, if specified) to delay before restarting. So nodemon will only restart your app the given number of seconds after the last file change.
If you are setting this value in
nodemon.json, the value will always be interpretted in milliseconds. E.g., the following are equivalent:
nodemon --delay 2.5
nodemon sends a kill signal to your application when it sees a file update. If you need to clean up on shutdown inside your script you can capture the kill signal and handle it yourself.
The following example will listen once for the
SIGUSR2 signal (used by nodemon to restart), run the clean up process and then kill itself for nodemon to continue control:
Note that the
process.kill is only called once your shutdown jobs are complete. Hat tip to Benjie Gillam for writing this technique up.
If you want growl like notifications when nodemon restarts or to trigger an action when an event happens, then you can either
require nodemon or add event actions to your
For example, to trigger a notification on a Mac when nodemon restarts,
nodemon.json looks like this:
A full list of available events is listed on the event states wiki. Note that you can bind to both states and messages.
Check out the gulp-nodemon plugin to integrate nodemon with the rest of your project's gulp workflow.
Check out the grunt-nodemon plugin to integrate nodemon with the rest of your project's grunt workflow.
nodemon, is it pronounced: node-mon, no-demon or node-e-mon (like pokémon)?
Well...I've been asked this many times before. I like that I've been asked this before. There's been bets as to which one it actually is.
The answer is simple, but possibly frustrating. I'm not saying (how I pronounce it). It's up to you to call it as you like. All answers are correct :)
Nodemon is not perfect, and CLI arguments has sprawled beyond where I'm completely happy, but perhaps it can be reduced a little one day.
See the FAQ and please add your own questions if you think they would help others.
Thank you to all our backers! 🙏
Support this project by becoming a sponsor. Your logo will show up here with a link to your website. Sponsor this project today ❤️