minimatch vs glob vs micromatch vs fast-glob

File and Path Pattern Matching in JavaScript

fast-glob, glob, micromatch, and minimatch are all JavaScript packages used for file and path pattern matching, but they operate at different layers of abstraction. minimatch and micromatch are pure pattern-matching libraries that determine whether a string matches a glob pattern, without interacting with the file system. micromatch is a modern, faster, and more feature-complete successor to minimatch. In contrast, glob and fast-glob are file system walkers that use pattern matchers internally to find actual files on disk. glob relies on minimatch and is considered legacy, while fast-glob uses micromatch and offers better performance, modern features like .gitignore support, and a cleaner async API.

Package	Downloads	Stars	Size	Issues	Publish	License

minimatch	420,607,128	3,455	449 kB	6	3 hours ago	BlueOak-1.0.0
glob	257,432,769	8,709	446 kB	5	3 hours ago	BlueOak-1.0.0
micromatch	99,785,083	3,008	56.6 kB	39	a year ago	MIT
fast-glob	91,042,713	2,797	98.4 kB	39	a year ago	MIT

Fast-Glob vs Glob vs Micromatch vs Minimatch: A Practical Guide for File Matching in JavaScript

When you need to find files in your project — whether it’s for a build tool, test runner, or file watcher — you’ll likely reach for one of these four packages. While they all deal with patterns and file paths, they solve different problems at different layers of the stack. Let’s break down what each does, how they relate, and when to use which.

🧩 Core Responsibilities: What Each Package Actually Does

`minimatch`

minimatch is the original pattern matcher. It implements Bash-style glob patterns (like *.js or src/**/*.ts) and tells you whether a single string matches a given pattern.

It doesn’t touch the file system — it only compares strings.

// minimatch: string-to-pattern matching only
const minimatch = require('minimatch');

console.log(minimatch('src/app.js', 'src/*.js')); // true
console.log(minimatch('src/utils/helper.js', 'src/*.js')); // false

`micromatch`

micromatch is a modern, faster, more feature-rich replacement for minimatch. It supports the same basic glob syntax but adds advanced features like extglobs (+(a|b)), braces (file.{js,ts}), and better Windows path handling.

Like minimatch, it only matches strings — no file system access.

// micromatch: enhanced string pattern matching
const micromatch = require('micromatch');

console.log(micromatch.isMatch('src/app.js', 'src/*.js')); // true
console.log(micromatch.isMatch('test.spec.js', '*.@(spec|test).js')); // true (extglob)

`glob`

glob combines file system traversal with pattern matching. It uses minimatch under the hood to find actual files on disk that match a pattern.

This is the classic “find files” utility used in many CLI tools and older build systems.

// glob: finds real files using fs + minimatch
const glob = require('glob');

const files = glob.sync('src/**/*.js');
console.log(files); // ['src/app.js', 'src/utils/helper.js', ...]

`fast-glob`

fast-glob is a modern, high-performance alternative to glob. Instead of minimatch, it uses micromatch for pattern matching, and it’s built with async-first design, better defaults, and optimizations for large directory trees.

It also supports advanced features like .gitignore respect and multiple patterns.

// fast-glob: fast, modern file finding
const fg = require('fast-glob');

const files = fg.sync(['src/**/*.js', 'lib/*.ts'], { dot: false });
console.log(files); // ['src/app.js', 'lib/core.ts', ...]

🔗 How They Relate: The Dependency Chain

There’s a clear hierarchy here:

minimatch and micromatch are pure pattern matchers (no I/O).
glob = file system walker + minimatch.
fast-glob = optimized file system walker + micromatch.

In fact, fast-glob was created to address performance and correctness issues in glob, much like micromatch improved upon minimatch.

⚙️ Feature Comparison: Real Code Examples

1. Basic File Matching

All four can be used to match or find .js files, but only two actually read the disk.

// minimatch – only checks one string
minimatch('app.js', '*.js'); // true

// micromatch – same, but faster and more features
micromatch.isMatch('app.js', '*.js'); // true

// glob – finds real files
glob.sync('*.js'); // ['app.js', 'index.js', ...]

// fast-glob – same goal, better performance
fg.sync('*.js'); // ['app.js', 'index.js', ...]

2. Handling Complex Patterns (Braces, Extglobs)

minimatch has limited support; micromatch excels here.

const pattern = 'src/*.{js,ts}';

// minimatch – requires { expand: true }
minimatch('src/app.js', pattern, { matchBase: true }); // may not work as expected

// micromatch – handles it natively
micromatch.isMatch('src/app.js', pattern); // true

// glob – inherits minimatch’s limitations
glob.sync(pattern); // works, but slower and less reliable

// fast-glob – leverages micromatch’s power
fg.sync(pattern); // fast and correct

3. Respecting `.gitignore`

Only fast-glob supports this out of the box.

// fast-glob: skip ignored files
fg.sync('**/*.js', { ignore: ['.gitignore'] });

// glob: no built-in support – you’d have to filter manually
const files = glob.sync('**/*.js');
// then cross-check with .gitignore yourself

4. Async Support

fast-glob is designed for async from the ground up. glob supports async, but its API feels dated.

// fast-glob – clean async/await
const files = await fg('**/*.js');

// glob – callback-based (promisified version available)
glob('**/*.js', (err, files) => { /*...*/ });

🛠️ When to Use Which: Practical Guidance

Don’t use `minimatch` in new projects

While not officially deprecated, minimatch is effectively in maintenance mode. Its pattern matching is less accurate, especially on Windows, and it lacks modern glob features. If you’re doing string-only matching, micromatch is strictly better.

Use `micromatch` when you only need to match strings

If you’re building a linter rule, a router, or any system that checks if a path should be included (without reading the file system), micromatch is your best bet. It’s fast, well-maintained, and handles edge cases correctly.

Avoid `glob` unless you’re maintaining legacy code

glob is still widely used, but it’s slow on large directories, has quirks with path separators, and doesn’t support modern glob features reliably. New projects should prefer fast-glob.

Default to `fast-glob` for file discovery

If you’re writing a bundler, test runner, or CLI tool that needs to find files on disk, fast-glob is the modern standard. It’s faster, more correct, respects .gitignore, and has a cleaner API.

📌 Summary Table

Package	Matches Strings?	Reads File System?	Modern Glob Features	Async-First	Ignores `.gitignore`
`minimatch`	✅	❌	❌ (limited)	❌	❌
`micromatch`	✅	❌	✅	✅ (sync/async APIs)	❌
`glob`	❌ (uses minimatch)	✅	❌	⚠️ (callback-based)	❌
`fast-glob`	❌ (uses micromatch)	✅	✅	✅	✅

💡 Final Recommendation

Think in layers:

Need to check if a path matches a rule? → Use micromatch.
Need to find actual files on disk? → Use fast-glob.

Avoid minimatch and glob in new code unless you have a specific compatibility requirement. The ecosystem has moved on, and for good reason — the newer tools are faster, more correct, and easier to use.

minimatch:
Choose minimatch only if you're working in an environment where you cannot add new dependencies or must match the behavior of very old tooling. It's functionally limited compared to micromatch, has known issues with Windows paths, and is effectively in maintenance mode. Not recommended for new development.
glob:
Choose glob only if you're maintaining legacy code that already depends on it or if you need strict compatibility with older Node.js versions. It works but is slower, less accurate with complex patterns, and lacks modern features like native .gitignore support. Avoid in new projects.
micromatch:
Choose micromatch when you only need to match strings against glob patterns without touching the file system. It's faster and more reliable than minimatch, supports advanced features like extglobs and braces, and is actively maintained. Perfect for routers, linters, or any logic that filters paths based on rules.
fast-glob:
Choose fast-glob when you need to find actual files on disk using glob patterns. It's the modern, high-performance replacement for glob, with better support for complex patterns, async/await, and built-in .gitignore respect. Ideal for build tools, test runners, and CLI applications that scan directories.

minimatch

glob

micromatch

fast-glob

minimatch

A minimal matching utility.

This is the matching library used internally by npm.

It works by converting glob expressions into JavaScript RegExp objects.

Usage

// hybrid module, load with require() or import
import { minimatch } from 'minimatch'
// or:
const { minimatch } = require('minimatch')

minimatch('bar.foo', '*.foo') // true!
minimatch('bar.foo', '*.bar') // false!
minimatch('bar.foo', '*.+(bar|foo)', { debug: true }) // true, and noisy!

Features

Supports these glob features:

Brace Expansion
Extended glob matching
"Globstar" ** matching
Posix character classes, like [[:alpha:]], supporting the full range of Unicode characters. For example, [[:alpha:]] will match against 'é', though [a-zA-Z] will not. Collating symbol and set matching is not supported, so [[=e=]] will not match 'é' and [[.ch.]] will not match 'ch' in locales where ch is considered a single character.

See:

man sh
man bash Pattern Matching
man 3 fnmatch
man 5 gitignore

Windows

Please only use forward-slashes in glob expressions.

Though windows uses either / or \ as its path separator, only / characters are used by this glob implementation. You must use forward-slashes only in glob expressions. Back-slashes in patterns will always be interpreted as escape characters, not path separators.

Note that \ or / will be interpreted as path separators in paths on Windows, and will match against / in glob expressions.

So just always use / in patterns.

UNC Paths

On Windows, UNC paths like //?/c:/... or //ComputerName/Share/... are handled specially.

Patterns starting with a double-slash followed by some non-slash characters will preserve their double-slash. As a result, a pattern like //* will match //x, but not /x.
Patterns staring with //?/<drive letter>: will not treat the ? as a wildcard character. Instead, it will be treated as a normal string.
Patterns starting with //?/<drive letter>:/... will match file paths starting with <drive letter>:/..., and vice versa, as if the //?/ was not present. This behavior only is present when the drive letters are a case-insensitive match to one another. The remaining portions of the path/pattern are compared case sensitively, unless nocase:true is set.

Note that specifying a UNC path using \ characters as path separators is always allowed in the file path argument, but only allowed in the pattern argument when windowsPathsNoEscape: true is set in the options.

Minimatch Class

Create a minimatch object by instantiating the minimatch.Minimatch class.

var Minimatch = require('minimatch').Minimatch
var mm = new Minimatch(pattern, options)

Properties

pattern The original pattern the minimatch object represents.
options The options supplied to the constructor.
set A 2-dimensional array of regexp or string expressions. Each row in the array corresponds to a brace-expanded pattern. Each item in the row corresponds to a single path-part. For example, the pattern {a,b/c}/d would expand to a set of patterns like:
```
  [ [ a, d ]
  , [ b, c, d ] ]
```
If a portion of the pattern doesn't have any "magic" in it (that is, it's something like "foo" rather than fo*o?), then it will be left as a string rather than converted to a regular expression.
regexp Created by the makeRe method. A single regular expression expressing the entire pattern. This is useful in cases where you wish to use the pattern somewhat like fnmatch(3) with FNM_PATH enabled.
negate True if the pattern is negated.
comment True if the pattern is a comment.
empty True if the pattern is "".

Methods

makeRe() Generate the regexp member if necessary, and return it. Will return false if the pattern is invalid.
match(fname) Return true if the filename matches the pattern, or false otherwise.
matchOne(fileArray, patternArray, partial) Take a /-split filename, and match it against a single row in the regExpSet. This method is mainly for internal use, but is exposed so that it can be used by a glob-walker that needs to avoid excessive filesystem calls.
hasMagic() Returns true if the parsed pattern contains any magic characters. Returns false if all comparator parts are string literals. If the magicalBraces option is set on the constructor, then it will consider brace expansions which are not otherwise magical to be magic. If not set, then a pattern like a{b,c}d will return false, because neither abd nor acd contain any special glob characters.

This does not mean that the pattern string can be used as a literal filename, as it may contain magic glob characters that are escaped. For example, the pattern \\* or [*] would not be considered to have magic, as the matching portion parses to the literal string '*' and would match a path named '*', not '\\*' or '[*]'. The minimatch.unescape() method may be used to remove escape characters.

All other methods are internal, and will be called as necessary.

minimatch(path, pattern, options)

Main export. Tests a path against the pattern using the options.

var isJS = minimatch(file, '*.js', { matchBase: true })

minimatch.filter(pattern, options)

Returns a function that tests its supplied argument, suitable for use with Array.filter. Example:

var javascripts = fileList.filter(minimatch.filter('*.js', { matchBase: true }))

minimatch.escape(pattern, options = {})

Escape all magic characters in a glob pattern, so that it will only ever match literal strings.

If the windowsPathsNoEscape option is used, then characters are escaped by wrapping in [], because a magic character wrapped in a character class can only be satisfied by that exact character.

Slashes (and backslashes in windowsPathsNoEscape mode) cannot be escaped or unescaped.

minimatch.unescape(pattern, options = {})

Un-escape a glob string that may contain some escaped characters.

If the windowsPathsNoEscape option is used, then square-brace escapes are removed, but not backslash escapes. For example, it will turn the string '[*]' into *, but it will not turn '\\*' into '*', because \ is a path separator in windowsPathsNoEscape mode.

When windowsPathsNoEscape is not set, then both brace escapes and backslash escapes are removed.

Slashes (and backslashes in windowsPathsNoEscape mode) cannot be escaped or unescaped.

minimatch.match(list, pattern, options)

Match against the list of files, in the style of fnmatch or glob. If nothing is matched, and options.nonull is set, then return a list containing the pattern itself.

var javascripts = minimatch.match(fileList, '*.js', { matchBase: true })

minimatch.makeRe(pattern, options)

Make a regular expression object from the pattern.

Options

All options are false by default.

debug

Dump a ton of stuff to stderr.

nobrace

Do not expand {a,b} and {1..3} brace sets.

noglobstar

Disable ** matching against multiple folder names.

dot

Allow patterns to match filenames starting with a period, even if the pattern does not explicitly have a period in that spot.

Note that by default, a/**/b will not match a/.d/b, unless dot is set.

noext

Disable "extglob" style patterns like +(a|b).

nocase

Perform a case-insensitive match.

nocaseMagicOnly

When used with {nocase: true}, create regular expressions that are case-insensitive, but leave string match portions untouched. Has no effect when used without {nocase: true}.

Useful when some other form of case-insensitive matching is used, or if the original string representation is useful in some other way.

nonull

When a match is not found by minimatch.match, return a list containing the pattern itself if this option is set. When not set, an empty list is returned if there are no matches.

magicalBraces

This only affects the results of the Minimatch.hasMagic method.

If the pattern contains brace expansions, such as a{b,c}d, but no other magic characters, then the Minimatch.hasMagic() method will return false by default. When this option set, it will return true for brace expansion as well as other magic glob characters.

matchBase

If set, then patterns without slashes will be matched against the basename of the path if it contains slashes. For example, a?b would match the path /xyz/123/acb, but not /xyz/acb/123.

nocomment

Suppress the behavior of treating # at the start of a pattern as a comment.

nonegate

Suppress the behavior of treating a leading ! character as negation.

flipNegate

Returns from negate expressions the same as if they were not negated. (Ie, true on a hit, false on a miss.)

partial

Compare a partial path to a pattern. As long as the parts of the path that are present are not contradicted by the pattern, it will be treated as a match. This is useful in applications where you're walking through a folder structure, and don't yet have the full path, but want to ensure that you do not walk down paths that can never be a match.

For example,

minimatch('/a/b', '/a/*/c/d', { partial: true }) // true, might be /a/b/c/d
minimatch('/a/b', '/**/d', { partial: true }) // true, might be /a/b/.../d
minimatch('/x/y/z', '/a/**/z', { partial: true }) // false, because x !== a

windowsPathsNoEscape

Use \\ as a path separator only, and never as an escape character. If set, all \\ characters are replaced with / in the pattern. Note that this makes it impossible to match against paths containing literal glob pattern characters, but allows matching with patterns constructed using path.join() and path.resolve() on Windows platforms, mimicking the (buggy!) behavior of earlier versions on Windows. Please use with caution, and be mindful of the caveat about Windows paths.

For legacy reasons, this is also set if options.allowWindowsEscape is set to the exact value false.

windowsNoMagicRoot

When a pattern starts with a UNC path or drive letter, and in nocase:true mode, do not convert the root portions of the pattern into a case-insensitive regular expression, and instead leave them as strings.

This is the default when the platform is win32 and nocase:true is set.

preserveMultipleSlashes

By default, multiple / characters (other than the leading // in a UNC path, see "UNC Paths" above) are treated as a single /.

That is, a pattern like a///b will match the file path a/b.

Set preserveMultipleSlashes: true to suppress this behavior.

optimizationLevel

A number indicating the level of optimization that should be done to the pattern prior to parsing and using it for matches.

Globstar parts ** are always converted to * when noglobstar is set, and multiple adjacent ** parts are converted into a single ** (ie, a/**/**/b will be treated as a/**/b, as this is equivalent in all cases).

0 - Make no further changes. In this mode, . and .. are maintained in the pattern, meaning that they must also appear in the same position in the test path string. Eg, a pattern like a/*/../c will match the string a/b/../c but not the string a/c.
1 - (default) Remove cases where a double-dot .. follows a pattern portion that is not **, ., .., or empty ''. For example, the pattern ./a/b/../* is converted to ./a/*, and so it will match the path string ./a/c, but not the path string ./a/b/../c. Dots and empty path portions in the pattern are preserved.
2 (or higher) - Much more aggressive optimizations, suitable for use with file-walking cases:
- Remove cases where a double-dot .. follows a pattern portion that is not **, ., or empty ''. Remove empty and . portions of the pattern, where safe to do so (ie, anywhere other than the last position, the first position, or the second position in a pattern starting with /, as this may indicate a UNC path on Windows).
- Convert patterns containing <pre>/**/../<p>/<rest> into the equivalent <pre>/{..,**}/<p>/<rest>, where <p> is a a pattern portion other than ., .., **, or empty ''.
- Dedupe patterns where a ** portion is present in one and omitted in another, and it is not the final path portion, and they are otherwise equivalent. So {a/**/b,a/b} becomes a/**/b, because ** matches against an empty path portion.
- Dedupe patterns where a * portion is present in one, and a non-dot pattern other than **, ., .., or '' is in the same position in the other. So a/{*,x}/b becomes a/*/b, because * can match against x.
While these optimizations improve the performance of file-walking use cases such as glob (ie, the reason this module exists), there are cases where it will fail to match a literal string that would have been matched in optimization level 1 or 0.

Specifically, while the Minimatch.match() method will optimize the file path string in the same ways, resulting in the same matches, it will fail when tested with the regular expression provided by Minimatch.makeRe(), unless the path string is first processed with minimatch.levelTwoFileOptimize() or similar.

platform

When set to win32, this will trigger all windows-specific behaviors (special handling for UNC paths, and treating \ as separators in file paths for comparison.)

Defaults to the value of process.platform.

Comparisons to other fnmatch/glob implementations

While strict compliance with the existing standards is a worthwhile goal, some discrepancies exist between minimatch and other implementations. Some are intentional, and some are unavoidable.

If the pattern starts with a ! character, then it is negated. Set the nonegate flag to suppress this behavior, and treat leading ! characters normally. This is perhaps relevant if you wish to start the pattern with a negative extglob pattern like !(a|B). Multiple ! characters at the start of a pattern will negate the pattern multiple times.

If a pattern starts with #, then it is treated as a comment, and will not match anything. Use \# to match a literal # at the start of a line, or set the nocomment flag to suppress this behavior.

The double-star character ** is supported by default, unless the noglobstar flag is set. This is supported in the manner of bsdglob and bash 4.1, where ** only has special significance if it is the only thing in a path part. That is, a/**/b will match a/x/y/b, but a/**b will not.

If an escaped pattern has no matches, and the nonull flag is set, then minimatch.match returns the pattern as-provided, rather than interpreting the character escapes. For example, minimatch.match([], "\\*a\\?") will return "\\*a\\?" rather than "*a?". This is akin to setting the nullglob option in bash, except that it does not resolve escaped pattern characters.

If brace expansion is not disabled, then it is performed before any other interpretation of the glob pattern. Thus, a pattern like +(a|{b),c)}, which would not be valid in bash or zsh, is expanded first into the set of +(a|b) and +(a|c), and those patterns are checked for validity. Since those two are valid, matching proceeds.

Negated extglob patterns are handled as closely as possible to Bash semantics, but there are some cases with negative extglobs which are exceedingly difficult to express in a JavaScript regular expression. In particular the negated pattern <start>!(<pattern>*|)* will in bash match anything that does not start with <start><pattern>. However, <start>!(<pattern>*)* will match paths starting with <start><pattern>, because the empty string can match against the negated portion. In this library, <start>!(<pattern>*|)* will not match any pattern starting with <start>, due to a difference in precisely which patterns are considered "greedy" in Regular Expressions vs bash path expansion. This may be fixable, but not without incurring some complexity and performance costs, and the trade-off seems to not be worth pursuing.

Note that fnmatch(3) in libc is an extremely naive string comparison matcher, which does not do anything special for slashes. This library is designed to be used in glob searching and file walkers, and so it does do special things with /. Thus, foo* will not match foo/bar in this library, even though it would in fnmatch(3).

Fast-Glob vs Glob vs Micromatch vs Minimatch: A Practical Guide for File Matching in JavaScript

🧩 Core Responsibilities: What Each Package Actually Does

minimatch

micromatch

glob

fast-glob

🔗 How They Relate: The Dependency Chain

⚙️ Feature Comparison: Real Code Examples

1. Basic File Matching

2. Handling Complex Patterns (Braces, Extglobs)

3. Respecting .gitignore

4. Async Support

🛠️ When to Use Which: Practical Guidance

Don’t use minimatch in new projects

Use micromatch when you only need to match strings

Avoid glob unless you’re maintaining legacy code

Default to fast-glob for file discovery

📌 Summary Table

💡 Final Recommendation

minimatch

Usage

Features

Windows

UNC Paths

Minimatch Class

Properties

Methods

minimatch(path, pattern, options)

minimatch.filter(pattern, options)

minimatch.escape(pattern, options = {})

minimatch.unescape(pattern, options = {})

minimatch.match(list, pattern, options)

minimatch.makeRe(pattern, options)

Options

debug

nobrace

noglobstar

dot

noext

nocase

nocaseMagicOnly

nonull

magicalBraces

matchBase

nocomment

nonegate

flipNegate

partial

windowsPathsNoEscape

windowsNoMagicRoot

preserveMultipleSlashes

optimizationLevel

platform

Comparisons to other fnmatch/glob implementations

`minimatch`

`micromatch`

`glob`

`fast-glob`

3. Respecting `.gitignore`

Don’t use `minimatch` in new projects

Use `micromatch` when you only need to match strings

Avoid `glob` unless you’re maintaining legacy code

Default to `fast-glob` for file discovery