GitHub - CapSoftware/globlin: A high-performance glob pattern matcher for Node.js, built in Rust.

A high-performance glob pattern matcher for Node.js, built in Rust.

Globlin is a drop-in replacement for glob v13 that delivers 2-3x faster performance on large directories while maintaining 100% API compatibility.

From the team behind Cap.

Features

• Fast: 2-3x faster than glob v13 on large directories (100k+ files)
• Drop-in replacement: Same API, same options, same behavior
• Cross-platform: Linux, macOS, Windows (x64 and ARM64)
• Zero config: Just replace your import
• Full pattern support: *, **, ?, [abc], {a,b}, extglobs, POSIX classes
• TypeScript first: Complete type definitions included

Installation

Quick Start

import { glob, globSync } from 'globlin'

// Async
const files = await glob('**/*.js')

// Sync
const files = globSync('**/*.ts')

// With options
const files = await glob('src/**/*.{js,ts}', {
  ignore: ['node_modules/**'],
  dot: true
})

Migration from glob

Globlin is designed as a drop-in replacement. Just change your import:

- import { glob, globSync } from 'glob'
+ import { glob, globSync } from 'globlin'

All APIs, options, and behaviors match glob v13.

API

Functions

// Async - returns Promise<string[]>
glob(pattern: string | string[], options?: GlobOptions): Promise<string[]>

// Sync - returns string[]
globSync(pattern: string | string[], options?: GlobOptions): string[]

// Streaming - returns Minipass stream
globStream(pattern: string | string[], options?: GlobOptions): Minipass<string>
globStreamSync(pattern: string | string[], options?: GlobOptions): Minipass<string>

// Iterators - returns generators
globIterate(pattern: string | string[], options?: GlobOptions): AsyncGenerator<string>
globIterateSync(pattern: string | string[], options?: GlobOptions): Generator<string>

// Utilities
hasMagic(pattern: string | string[], options?: GlobOptions): boolean
escape(pattern: string, options?: GlobOptions): string
unescape(pattern: string, options?: GlobOptions): string

Glob Class

const g = new Glob('**/*.js', { cwd: '/project', dot: true })

// Methods
await g.walk()        // Promise<string[]>
g.walkSync()          // string[]
g.stream()            // Minipass<string>
g.streamSync()        // Minipass<string>
g.iterate()           // AsyncGenerator<string>
g.iterateSync()       // Generator<string>

// Iteration
for await (const file of g) { }
for (const file of g) { }

// Cache reuse (pass Glob as options)
const g2 = new Glob('**/*.ts', g)  // Inherits options from g

Options

All glob v13 options are supported:

See the full options reference for all 22 options.

Pattern Syntax

Benchmarks comparing globlin vs glob v13 vs fast-glob (Apple M1 Pro, SSD):

Large Directory (100,000 files)

Summary by Fixture Size

Summary by Pattern Type

Overall: 2.8x faster than glob, competitive with fast-glob.

Performance Characteristics

Glob operations are I/O-bound (~85% of execution time is spent in readdir syscalls). Globlin optimizes both I/O and CPU:

• I/O reduction: Depth-limited walking, prefix-based traversal, directory pruning
• CPU optimization: Rust pattern matching, fast-path extensions, compiled patterns
• Static patterns: Near-instant lookups without directory traversal

When to Use Globlin

• Large directories (1000+ files): 2-3x faster
• Build tools: Webpack, Rollup, esbuild plugins
• Test runners: Jest, Vitest, Mocha file discovery
• Linters: ESLint, Prettier file matching
• Monorepos: Multiple package traversal

Compatibility

Supported APIs

• All 6 core functions (glob, globSync, globStream, globStreamSync, globIterate, globIterateSync)
• Full Glob class with 8 methods and iterator protocols
• All 3 utility functions (hasMagic, escape, unescape)
• All 22 options (except fs and scurry which are Node.js-specific)
• Re-exports: Minimatch, minimatch, PathScurry, Path, Minipass

Supported Platforms

Node.js Versions

• Node.js 20.x: Supported
• Node.js 22.x: Supported

Documentation

• Migration Guide
• Performance Tuning
• API Reference
• Options Reference

Contributing

Contributions are welcome! Please read our contributing guidelines before submitting a PR.

Development

# Install dependencies
npm install

# Build the native module
npm run build

# Run tests
npm test

# Run benchmarks
npm run bench

Running Benchmarks

# Quick benchmark (small fixture)
npm run bench:small

# Standard benchmark (medium fixture, 20k files)
npm run bench:medium

# Full benchmark (large fixture, 100k files)
npm run bench:large

Credits

• glob - The original glob implementation that this project aims to replace
• minimatch - Pattern matching library
• path-scurry - Path resolution library
• NAPI-RS - Rust bindings for Node.js

License

MIT License - see LICENSE for details.