_Pre-built binaries for various NodeJS versions are made available on a best-effort basis._
Only the current stable and supported LTS releases (Node 18+) are actively tested against.
_There may be an interval between the release of the module and the availability of the compiled modules._
Currently, we have pre-built binaries that support the following platforms:
1. Windows x64 and arm64
2. Linux x64 and arm64 (GlibC and musl)
3. macOS x64 and arm64
If you face an error like this:

Make sure you have the appropriate dependencies installed and configured for your platform. You can find installation instructions for the dependencies for some common platforms [in this page][depsinstall].
Usage  Copy Chapter
async (recommended)  Copy Section

#### To hash a password:
Technique 1 (generate a salt and hash on separate function calls):

Technique 2 (auto-gen a salt and hash):

Note that both techniques achieve the same end-result.
#### To check a password:

A Note on Timing Attacks
with promises  Copy Section
bcrypt uses whatever Promise implementation is available in global.Promise. NodeJS has a native Promise implementation built in. However, this should work in any Promises/A+ compliant implementation.
Async methods that accept a callback, return a Promise when the callback is not specified if Promise support is available.
The Promise implementation can be customized using the bcrypt.promises.use() method:

This is also compatible with async/await

ESM import  Copy Section

sync  Copy Section

#### To hash a password:
Technique 1 (generate a salt and hash on separate function calls):

Technique 2 (auto-gen a salt and hash):

As with async, both techniques achieve the same end-result.
#### To check a password:

A Note on Timing Attacks
Why is async mode recommended over sync mode?  Copy Section

We recommend using async API if you use bcrypt on a server. Bcrypt hashing is CPU intensive which will cause the sync APIs to block the event loop and prevent your application from servicing any inbound requests or events. The async version uses a thread pool which does not block the main event loop.
API  Copy Chapter
BCrypt.
  * genSaltSync(rounds, minor)
    * rounds - [OPTIONAL] - the cost of processing the data. (default - 10)
    * minor - [OPTIONAL] - minor version of bcrypt to use. (default - b)
  * genSalt(rounds, minor, cb)
    * rounds - [OPTIONAL] - the cost of processing the data. (default - 10)
    * minor - [OPTIONAL] - minor version of bcrypt to use. (default - b)
    * cb - [OPTIONAL] - a callback to be fired once the salt has been generated. If cb is not specified, a Promise is returned if Promise support is available.
      * err - First parameter to the callback detailing any errors.
      * salt - Second parameter to the callback providing the generated salt.
  * hashSync(data, salt)
    * data - [REQUIRED] - the data to be encrypted (string or Buffer).
    * salt - [REQUIRED] - the salt to be used to hash the password. If specified as a number then a salt will be generated with the specified number of rounds and used (see example under Usage).
  * hash(data, salt, cb)
    * data - [REQUIRED] - the data to be encrypted (string or Buffer).
    * salt - [REQUIRED] - the salt to be used to hash the password. If specified as a number then a salt will be generated with the specified number of rounds and used (see example under Usage).
    * cb - [OPTIONAL] - a callback to be fired once the data has been encrypted. If cb is not specified, a Promise is returned if Promise support is available.
      * err - First parameter to the callback detailing any errors.
      * encrypted - Second parameter to the callback providing the encrypted form.
  * compareSync(data, encrypted)
    * data - [REQUIRED] - data to compare (string or Buffer).
    * encrypted - [REQUIRED] - data to be compared to.
  * compare(data, encrypted, cb)
    * data - [REQUIRED] - data to compare (string or Buffer).
    * encrypted - [REQUIRED] - data to be compared to.
    * cb - [OPTIONAL] - a callback to be fired once the data has been compared. If cb is not specified, a Promise is returned if Promise support is available.
      * err - First parameter to the callback detailing any errors.
      * same - Second parameter to the callback providing whether the data and encrypted forms match [true | false].
  * getRounds(encrypted) - return the number of rounds used to encrypt a given hash
    * encrypted - [REQUIRED] - hash from which the number of rounds used should be extracted.
  * promises.use(promiseImplementation) - change the Promise implementation that bcrypt uses
    * promiseImplementation - [REQUIRED] - a Promises/A+ compatible implementation to be used.
A Note on Rounds  Copy Chapter
A note about the cost: when you are hashing your data, the module will go through a series of rounds to give you a secure hash. The value you submit is not just the number of rounds the module will go through to hash your data. The module will use the value you enter and go through 2^rounds hashing iterations.
From @garthk, on a 2GHz core you can roughly expect:
    rounds=8 : ~40 hashes/sec
    rounds=9 : ~20 hashes/sec
    rounds=10: ~10 hashes/sec
    rounds=11: ~5  hashes/sec
    rounds=12: 2-3 hashes/sec
    rounds=13: ~1 sec/hash
    rounds=14: ~1.5 sec/hash
    rounds=15: ~3 sec/hash
    rounds=25: ~1 hour/hash
    rounds=31: 2-3 days/hash

A Note on Timing Attacks  Copy Chapter
Because it's come up multiple times in this project and other bcrypt projects, it needs to be said. The bcrypt library is not susceptible to timing attacks. From codahale/bcrypt-ruby#42:
One of the desired properties of a cryptographic hash function is preimage attack resistance, which means there is no shortcut for generating a message which, when hashed, produces a specific digest.
A great thread on this, in much more detail can be found @ codahale/bcrypt-ruby#43
If you're unfamiliar with timing attacks and want to learn more you can find a great writeup @ [A Lesson In Timing Attacks][timingatk]
However, the comparison function is _not_ time safe (constant-time), as it may exit early when a mismatch is found. Normally, this could enable a timing attack, but because it compares full bcrypt hash digests rather than raw passwords, and hashes are preimage-resistant, an attacker cannot gain any information about the stored hash. If you use the comparison function outside the bcrypt library, we cannot guarantee its security. Keep this in mind when using the library.
Hash Info  Copy Chapter
The characters that comprise the resultant hash are ./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789$.
Resultant hashes will be 60 characters long and they will include the salt among other parameters, as follows:
$[algorithm]$[cost]$[salt][hash]
- 2 chars hash algorithm identifier prefix. "$2a$" or "$2b$" indicates BCrypt
- Cost-factor (n). Represents the exponent used to determine how many iterations 2^n
- 16-byte (128-bit) salt, base64 encoded to 22 characters
- 24-byte (192-bit) hash, base64 encoded to 31 characters
Example:

Testing  Copy Chapter
If you create a pull request, tests better pass :)