diff --git a/doc/api/fs.md b/doc/api/fs.md
index 5cf89e0eb0f1d8..9f418cfbddd1f5 100644
--- a/doc/api/fs.md
+++ b/doc/api/fs.md
@@ -1292,6 +1292,9 @@ closed after the iterator exits.
 <!-- YAML
 added: v10.0.0
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/49255
+    description: Extended `recursive` option to allow a function for filtering.
   - version:
     - v20.1.0
     - v18.17.0
@@ -1306,7 +1309,12 @@ changes:
 * `options` {string|Object}
   * `encoding` {string} **Default:** `'utf8'`
   * `withFileTypes` {boolean} **Default:** `false`
-  * `recursive` {boolean} **Default:** `false`
+  * `recursive` {boolean|Function} **Default:** `false`
+    * `directory` {string|fs.Dirent} A given directory file system artifact
+      name.
+    * `depth` {integer} The number of steps traversed from the supplied base
+      path.
+    * Returns: {boolean}
 * Returns: {Promise}  Fulfills with an array of the names of the files in
   the directory excluding `'.'` and `'..'`.
 
@@ -1320,6 +1328,13 @@ will be passed as {Buffer} objects.
 If `options.withFileTypes` is set to `true`, the resolved array will contain
 {fs.Dirent} objects.
 
+When passing a function to `options.recursive` the first argument populates
+with the name of a directory, or {fs.Dirent} object if `options.withFileTypes`
+is true, and directory depth relative to the base path as the second argument.
+This function expects to return a boolean which determines the descendant
+directories to traverse. Filtering using this function does not limit what
+populates in the resultant list, only which descendant directories to traverse.
+
 ```mjs
 import { readdir } from 'node:fs/promises';
 
@@ -1332,6 +1347,68 @@ try {
 }
 ```
 
+Example with unfiltered recursion.
+
+```mjs
+import { readdir } from 'node:fs/promises';
+
+try {
+  // Will traverse all descendant directories, fully recursive
+  const files = await readdir(path, { recursive: true });
+  for (const file of files)
+    console.log(file);
+} catch (err) {
+  console.error(err);
+}
+```
+
+Example with filtered recursion.
+
+```mjs
+import { readdir } from 'node:fs/promises';
+
+try {
+  const files = await readdir(path, { recursive: function(directory, depth) {
+    // Will not traverse directories with a depth greater than 4 and
+    // will traverse directories only that contain 'system' in the
+    // directory's name
+    return (directory.includes('system') && depth < 5);
+  } });
+  for (const file of files)
+    console.log(file);
+} catch (err) {
+  console.error(err);
+}
+```
+
+Example with filtered recursion and dirent.
+
+```mjs
+import { readdir } from 'node:fs/promises';
+
+try {
+  const files = await readdir(path, {
+    withFileTypes: true,
+    recursive: function(directory, depth) {
+    // Will not traverse directories with a depth greater than 4 and
+    // will traverse directories only that contain 'system' in the
+    // directory's name and 'games' in the path string
+      return (
+        directory.name.includes('system') &&
+        depth < 5
+      );
+    },
+  });
+  for (const file of files)
+    console.log(file);
+} catch (err) {
+  console.error(err);
+}
+// Should expect result: 'games/combat/system'
+// Should not expect result: 'action/q/v/games/combat/system'
+// Should not expect result: 'games/action'
+```
+
 ### `fsPromises.readFile(path[, options])`
 
 <!-- YAML
@@ -3584,6 +3661,9 @@ above values.
 <!-- YAML
 added: v0.1.8
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/49255
+    description: Extended `recursive` option to allow a function for filtering.
   - version:
     - v20.1.0
     - v18.17.0
@@ -3618,7 +3698,12 @@ changes:
 * `options` {string|Object}
   * `encoding` {string} **Default:** `'utf8'`
   * `withFileTypes` {boolean} **Default:** `false`
-  * `recursive` {boolean} **Default:** `false`
+  * `recursive` {boolean|Function} **Default:** `false`
+    * `directory` {string|fs.Dirent} A given directory file system artifact
+      name.
+    * `depth` {integer} The number of steps traversed from the supplied base
+      path.
+    * Returns: {boolean}
 * `callback` {Function}
   * `err` {Error}
   * `files` {string\[]|Buffer\[]|fs.Dirent\[]}
@@ -3637,6 +3722,85 @@ the filenames returned will be passed as {Buffer} objects.
 If `options.withFileTypes` is set to `true`, the `files` array will contain
 {fs.Dirent} objects.
 
+When passing a function to `options.recursive` the first argument populates
+with the name of a directory, or {fs.Dirent} object if `options.withFileTypes`
+is true, and directory depth relative to the base path as the second argument.
+This function expects to return a boolean which determines the descendant
+directories to traverse. Filtering using this function does not limit what
+populates in the resultant list, only which descendant directories to traverse.
+
+```mjs
+import { readdir } from 'node:fs';
+
+function callback(err, files) {
+  if (err === null) {
+    console.log(files);
+  }
+}
+fs.readdir(path, callback);
+```
+
+Example with unfiltered recursion.
+
+```mjs
+import { readdir } from 'node:fs';
+
+function callback(err, files) {
+  if (err === null) {
+    console.log(files);
+  }
+}
+// Will traverse all descendant directories, fully recursive
+fs.readdir(path, { recursion: true }, callback);
+```
+
+Example with filtered recursion.
+
+```mjs
+import { readdir } from 'node:fs';
+
+function callback(err, files) {
+  if (err === null) {
+    console.log(files);
+  }
+}
+fs.readdir(path, {
+  recursion: function(directory, depth) {
+    // Will not traverse directories with a depth greater than 4 and
+    // will traverse directories only that contain 'system' in the
+    // directory's name
+    return (directory.includes('system') && depth < 5);
+  },
+}, callback);
+```
+
+Example with filtered recursion and dirent.
+
+```mjs
+import { readdir } from 'node:fs';
+
+function callback(err, files) {
+  if (err === null) {
+    console.log(files);
+  }
+}
+fs.readdir(path, {
+  withFileTypes: true,
+  recursion: function(directory, depth) {
+    // Will not traverse directories with a depth greater than 4 and
+    // will traverse directories only that contain 'system' in the
+    // directory's name and 'games' in the path string
+    return (
+      directory.name.includes('system') &&
+      depth < 5
+    );
+  },
+}, callback);
+// Should expect result: 'games/combat/system'
+// Should not expect result: 'action/q/v/games/combat/system'
+// Should not expect result: 'games/action'
+```
+
 ### `fs.readFile(path[, options], callback)`
 
 <!-- YAML
@@ -5667,6 +5831,9 @@ this API: [`fs.open()`][].
 <!-- YAML
 added: v0.1.21
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/49255
+    description: Extended `recursive` option to allow a function for filtering.
   - version:
     - v20.1.0
     - v18.17.0
@@ -5685,7 +5852,12 @@ changes:
 * `options` {string|Object}
   * `encoding` {string} **Default:** `'utf8'`
   * `withFileTypes` {boolean} **Default:** `false`
-  * `recursive` {boolean} **Default:** `false`
+  * `recursive` {boolean|Function} **Default:** `false`
+    * `directory` {string|fs.Dirent} A given directory file system artifact
+      name.
+    * `depth` {integer} The number of steps traversed from the supplied base
+      path.
+    * Returns: {boolean}
 * Returns: {string\[]|Buffer\[]|fs.Dirent\[]}
 
 Reads the contents of the directory.
@@ -5700,6 +5872,65 @@ the filenames returned will be passed as {Buffer} objects.
 If `options.withFileTypes` is set to `true`, the result will contain
 {fs.Dirent} objects.
 
+When passing a function to `options.recursive` the first argument populates
+with the name of a directory, or {fs.Dirent} object if `options.withFileTypes`
+is true, and directory depth relative to the base path as the second argument.
+This function expects to return a boolean which determines the descendant
+directories to traverse. Filtering using this function does not limit what
+populates in the resultant list, only which descendant directories to traverse.
+
+```mjs
+import { readdir } from 'node:fs';
+
+const files = fs.readdirSync(path);
+```
+
+Example with unfiltered recursion.
+
+```mjs
+import { readdir } from 'node:fs';
+
+// Will traverse all descendant directories, fully recursive
+const files = fs.readdirSync(path, { recursion: true });
+```
+
+Example with filtered recursion.
+
+```mjs
+import { readdir } from 'node:fs';
+
+const files = fs.readdirSync(path, {
+  recursion: function(directory, depth) {
+    // Will not traverse directories with a depth greater than 4 and
+    // will traverse directories only that contain 'system' in the
+    // directory's name
+    return (directory.includes('system') && depth < 5);
+  },
+});
+```
+
+Example with filtered recursion and dirent.
+
+```mjs
+import { readdir } from 'node:fs';
+
+const files = fs.readdirSync(path, {
+  withFileTypes: true,
+  recursion: function(directory, depth) {
+    // Will not traverse directories with a depth greater than 4 and
+    // will traverse directories only that contain 'system' in the
+    // directory's name and 'games' in the path string
+    return (
+      directory.name.includes('system') &&
+      depth < 5
+    );
+  },
+});
+// Should expect result: 'games/combat/system'
+// Should not expect result: 'action/q/v/games/combat/system'
+// Should not expect result: 'games/action'
+```
+
 ### `fs.readFileSync(path[, options])`
 
 <!-- YAML
diff --git a/lib/fs.js b/lib/fs.js
index b17cf4f10cd3c1..4409bee7e5c71d 100644
--- a/lib/fs.js
+++ b/lib/fs.js
@@ -58,7 +58,10 @@ const {
 } = constants;
 
 const pathModule = require('path');
-const { isArrayBufferView } = require('internal/util/types');
+const {
+  isArrayBufferView,
+  isPromise,
+} = require('internal/util/types');
 
 const binding = internalBinding('fs');
 
@@ -70,6 +73,7 @@ const {
   codes: {
     ERR_FS_FILE_TOO_LARGE,
     ERR_INVALID_ARG_VALUE,
+    ERR_INVALID_RETURN_VALUE,
   },
   AbortError,
   uvErrmapGet,
@@ -1428,15 +1432,29 @@ function mkdirSync(path, options) {
  * @returns {string[] | Dirent[]}
  */
 function readdirSyncRecursive(basePath, options) {
+  if (isPromise(options.recursive)) {
+    throw new ERR_INVALID_RETURN_VALUE('function', 'options.recursive', options.recursive);
+  }
+
   const withFileTypes = Boolean(options.withFileTypes);
   const encoding = options.encoding;
 
   const readdirResults = [];
-  const pathsQueue = [basePath];
+  const pathsQueue = [[basePath, 0]];
 
   const ctx = { path: basePath };
-  function read(path) {
+  function read({ 0: path, 1: depth }) {
     ctx.path = path;
+
+    function filterCheck(item, dirEnt) {
+      if (typeof options.recursive !== 'function' ||
+        (dirEnt === true && typeof item.name !== 'string') || (dirEnt === false && typeof item !== 'string')
+      ) {
+        return true;
+      }
+      return options.recursive(item, depth);
+    }
+
     const readdirResult = binding.readdir(
       pathModule.toNamespacedPath(path),
       encoding,
@@ -1455,8 +1473,8 @@ function readdirSyncRecursive(basePath, options) {
       for (let i = 0; i < length; i++) {
         const dirent = getDirent(path, readdirResult[0][i], readdirResult[1][i]);
         ArrayPrototypePush(readdirResults, dirent);
-        if (dirent.isDirectory()) {
-          ArrayPrototypePush(pathsQueue, pathModule.join(dirent.path, dirent.name));
+        if (dirent.isDirectory() && filterCheck(dirent, true)) {
+          ArrayPrototypePush(pathsQueue, [pathModule.join(dirent.path, dirent.name), depth + 1]);
         }
       }
     } else {
@@ -1466,8 +1484,8 @@ function readdirSyncRecursive(basePath, options) {
         const stat = binding.internalModuleStat(resultPath);
         ArrayPrototypePush(readdirResults, relativeResultPath);
         // 1 indicates directory
-        if (stat === 1) {
-          ArrayPrototypePush(pathsQueue, resultPath);
+        if (stat === 1 && filterCheck(readdirResult[i], false)) {
+          ArrayPrototypePush(pathsQueue, [resultPath, depth + 1]);
         }
       }
     }
@@ -1486,6 +1504,7 @@ function readdirSyncRecursive(basePath, options) {
  * @param {string | {
  *   encoding?: string;
  *   withFileTypes?: boolean;
+ *   recursive?: boolean | (directory: string | Buffer | Dirent, depth: number) => boolean;
  *   }} [options]
  * @param {(
  *   err?: Error,
@@ -1497,9 +1516,6 @@ function readdir(path, options, callback) {
   callback = makeCallback(typeof options === 'function' ? options : callback);
   options = getOptions(options);
   path = getValidatedPath(path);
-  if (options.recursive != null) {
-    validateBoolean(options.recursive, 'options.recursive');
-  }
 
   if (options.recursive) {
     callback(null, readdirSyncRecursive(path, options));
@@ -1528,16 +1544,13 @@ function readdir(path, options, callback) {
  * @param {string | {
  *   encoding?: string;
  *   withFileTypes?: boolean;
- *   recursive?: boolean;
+ *   recursive?: boolean | (directory: string | Buffer | Dirent, depth: number) => boolean;
  *   }} [options]
  * @returns {string | Buffer[] | Dirent[]}
  */
 function readdirSync(path, options) {
   options = getOptions(options);
   path = getValidatedPath(path);
-  if (options.recursive != null) {
-    validateBoolean(options.recursive, 'options.recursive');
-  }
 
   if (options.recursive) {
     return readdirSyncRecursive(path, options);
diff --git a/lib/internal/fs/promises.js b/lib/internal/fs/promises.js
index bc506b9be82fbc..b258d13d3c09cc 100644
--- a/lib/internal/fs/promises.js
+++ b/lib/internal/fs/promises.js
@@ -773,6 +773,7 @@ async function mkdir(path, options) {
 }
 
 async function readdirRecursive(originalPath, options) {
+  originalPath = pathModule.resolve(originalPath);
   const result = [];
   const queue = [
     [
@@ -783,17 +784,20 @@ async function readdirRecursive(originalPath, options) {
         !!options.withFileTypes,
         kUsePromises,
       ),
+      0,
     ],
   ];
 
-
   if (options.withFileTypes) {
     while (queue.length > 0) {
       // If we want to implement BFS make this a `shift` call instead of `pop`
-      const { 0: path, 1: readdir } = ArrayPrototypePop(queue);
+      const { 0: path, 1: readdir, 2: depth } = ArrayPrototypePop(queue);
       for (const dirent of getDirents(path, readdir)) {
         ArrayPrototypePush(result, dirent);
-        if (dirent.isDirectory()) {
+        if (
+          dirent.isDirectory() &&
+          (typeof options.recursive !== 'function' || await options.recursive(dirent, depth))
+        ) {
           const direntPath = pathModule.join(path, dirent.name);
           ArrayPrototypePush(queue, [
             direntPath,
@@ -803,13 +807,14 @@ async function readdirRecursive(originalPath, options) {
               true,
               kUsePromises,
             ),
+            depth + 1,
           ]);
         }
       }
     }
   } else {
     while (queue.length > 0) {
-      const { 0: path, 1: readdir } = ArrayPrototypePop(queue);
+      const { 0: path, 1: readdir, 2: depth } = ArrayPrototypePop(queue);
       for (const ent of readdir) {
         const direntPath = pathModule.join(path, ent);
         const stat = binding.internalModuleStat(direntPath);
@@ -817,7 +822,10 @@ async function readdirRecursive(originalPath, options) {
           result,
           pathModule.relative(originalPath, direntPath),
         );
-        if (stat === 1) {
+        if (
+          stat === 1 &&
+          (typeof options.recursive !== 'function' || await options.recursive(ent, depth))
+        ) {
           ArrayPrototypePush(queue, [
             direntPath,
             await binding.readdir(
@@ -826,6 +834,7 @@ async function readdirRecursive(originalPath, options) {
               false,
               kUsePromises,
             ),
+            depth + 1,
           ]);
         }
       }
diff --git a/test/sequential/test-fs-readdir-recursive.js b/test/sequential/test-fs-readdir-recursive.js
index 2775573837786d..bfd1c0600c14e6 100644
--- a/test/sequential/test-fs-readdir-recursive.js
+++ b/test/sequential/test-fs-readdir-recursive.js
@@ -61,7 +61,7 @@ const fileStructure = [
   [ 'xx', [ 'foo', 'bar' ] ],
   [ 'yy', [ 'foo', 'bar' ] ],
   [ 'zz', [ 'foo', 'bar' ] ],
-  [ 'abc', [ ['def', [ 'foo', 'bar' ] ], ['ghi', [ 'foo', 'bar' ] ] ] ],
+  [ 'abc', [ [ 'def', [ 'foo', [ 'bar', [ 'bim', 'bam' ] ] ] ], [ 'ghi', [ 'foo', [ 'bar', [ 'bim', 'bam' ] ] ] ] ] ],
 ];
 
 function createFiles(path, fileStructure) {
@@ -79,6 +79,137 @@ function createFiles(path, fileStructure) {
 // Make sure tmp directory is clean
 tmpdir.refresh();
 
+const results = [
+  [
+    'a', 'a/bar', 'a/foo', 'aa', 'aa/bar', 'aa/foo',
+    'abc', 'abc/def', 'abc/def/bar', 'abc/def/bar/bam', 'abc/def/bar/bim',
+    'abc/def/foo', 'abc/ghi', 'abc/ghi/bar',
+    'abc/ghi/bar/bam', 'abc/ghi/bar/bim', 'abc/ghi/foo',
+    'b', 'b/bar', 'b/foo', 'bb', 'bb/bar', 'bb/foo',
+    'c', 'c/bar', 'c/foo', 'cc', 'cc/bar', 'cc/foo',
+    'd', 'd/bar', 'd/foo', 'dd', 'dd/bar', 'dd/foo',
+    'e', 'e/bar', 'e/foo', 'ee', 'ee/bar', 'ee/foo',
+    'f', 'f/bar', 'f/foo', 'ff', 'ff/bar', 'ff/foo',
+    'g', 'g/bar', 'g/foo', 'gg', 'gg/bar', 'gg/foo',
+    'h', 'h/bar', 'h/foo', 'hh', 'hh/bar', 'hh/foo',
+    'i', 'i/bar', 'i/foo', 'ii', 'ii/bar', 'ii/foo',
+    'j', 'j/bar', 'j/foo', 'jj', 'jj/bar', 'jj/foo',
+    'k', 'k/bar', 'k/foo', 'kk', 'kk/bar', 'kk/foo',
+    'l', 'l/bar', 'l/foo', 'll', 'll/bar', 'll/foo',
+    'm', 'm/bar', 'm/foo', 'mm', 'mm/bar', 'mm/foo',
+    'n', 'n/bar', 'n/foo', 'nn', 'nn/bar', 'nn/foo',
+    'o', 'o/bar', 'o/foo', 'oo', 'oo/bar', 'oo/foo',
+    'p', 'p/bar', 'p/foo', 'pp', 'pp/bar', 'pp/foo',
+    'q', 'q/bar', 'q/foo', 'qq', 'qq/bar', 'qq/foo',
+    'r', 'r/bar', 'r/foo', 'rr', 'rr/bar', 'rr/foo',
+    's', 's/bar', 's/foo', 'ss', 'ss/bar', 'ss/foo',
+    'symlinks', 'symlinks/symlink-src-dir', 'symlinks/symlink-src-file',
+    'symlinks/symlink-target-dir', 'symlinks/symlink-target-file',
+    't', 't/bar', 't/foo', 'tt', 'tt/bar', 'tt/foo',
+    'u', 'u/bar', 'u/foo', 'uu', 'uu/bar', 'uu/foo',
+    'v', 'v/bar', 'v/foo', 'vv', 'vv/bar', 'vv/foo',
+    'w', 'w/bar', 'w/foo', 'ww', 'ww/bar', 'ww/foo',
+    'x', 'x/bar', 'x/foo', 'xx', 'xx/bar', 'xx/foo',
+    'y', 'y/bar', 'y/foo', 'yy', 'yy/bar', 'yy/foo',
+    'z', 'z/bar', 'z/foo', 'zz', 'zz/bar', 'zz/foo',
+  ],
+  [
+    'a', 'a/bar', 'a/foo', 'aa', 'aa/bar', 'aa/foo',
+    'abc', 'abc/def', 'abc/ghi',
+    'b', 'b/bar', 'b/foo', 'bb', 'bb/bar', 'bb/foo',
+    'c', 'c/bar', 'c/foo', 'cc', 'cc/bar', 'cc/foo',
+    'd', 'd/bar', 'd/foo', 'dd', 'dd/bar', 'dd/foo',
+    'e', 'e/bar', 'e/foo', 'ee', 'ee/bar', 'ee/foo',
+    'f', 'f/bar', 'f/foo', 'ff', 'ff/bar', 'ff/foo',
+    'g', 'g/bar', 'g/foo', 'gg', 'gg/bar', 'gg/foo',
+    'h', 'h/bar', 'h/foo', 'hh', 'hh/bar', 'hh/foo',
+    'i', 'i/bar', 'i/foo', 'ii', 'ii/bar', 'ii/foo',
+    'j', 'j/bar', 'j/foo', 'jj', 'jj/bar', 'jj/foo',
+    'k', 'k/bar', 'k/foo', 'kk', 'kk/bar', 'kk/foo',
+    'l', 'l/bar', 'l/foo', 'll', 'll/bar', 'll/foo',
+    'm', 'm/bar', 'm/foo', 'mm', 'mm/bar', 'mm/foo',
+    'n', 'n/bar', 'n/foo', 'nn', 'nn/bar', 'nn/foo',
+    'o', 'o/bar', 'o/foo', 'oo', 'oo/bar', 'oo/foo',
+    'p', 'p/bar', 'p/foo', 'pp', 'pp/bar', 'pp/foo',
+    'q', 'q/bar', 'q/foo', 'qq', 'qq/bar', 'qq/foo',
+    'r', 'r/bar', 'r/foo', 'rr', 'rr/bar', 'rr/foo',
+    's', 's/bar', 's/foo', 'ss', 'ss/bar', 'ss/foo',
+    'symlinks', 'symlinks/symlink-src-dir', 'symlinks/symlink-src-file',
+    'symlinks/symlink-target-dir', 'symlinks/symlink-target-file',
+    't', 't/bar', 't/foo', 'tt', 'tt/bar', 'tt/foo',
+    'u', 'u/bar', 'u/foo', 'uu', 'uu/bar', 'uu/foo',
+    'v', 'v/bar', 'v/foo', 'vv', 'vv/bar', 'vv/foo',
+    'w', 'w/bar', 'w/foo', 'ww', 'ww/bar', 'ww/foo',
+    'x', 'x/bar', 'x/foo', 'xx', 'xx/bar', 'xx/foo',
+    'y', 'y/bar', 'y/foo', 'yy', 'yy/bar', 'yy/foo',
+    'z', 'z/bar', 'z/foo', 'zz', 'zz/bar', 'zz/foo',
+  ],
+  [
+    'a', 'a/bar', 'a/foo', 'aa', 'aa/bar', 'aa/foo',
+    'abc', 'abc/def', 'abc/def/bar', 'abc/def/foo',
+    'abc/ghi', 'abc/ghi/bar', 'abc/ghi/foo',
+    'b', 'b/bar', 'b/foo', 'bb', 'bb/bar', 'bb/foo',
+    'c', 'c/bar', 'c/foo', 'cc', 'cc/bar', 'cc/foo',
+    'd', 'd/bar', 'd/foo', 'dd', 'dd/bar', 'dd/foo',
+    'e', 'e/bar', 'e/foo', 'ee', 'ee/bar', 'ee/foo',
+    'f', 'f/bar', 'f/foo', 'ff', 'ff/bar', 'ff/foo',
+    'g', 'g/bar', 'g/foo', 'gg', 'gg/bar', 'gg/foo',
+    'h', 'h/bar', 'h/foo', 'hh', 'hh/bar', 'hh/foo',
+    'i', 'i/bar', 'i/foo', 'ii', 'ii/bar', 'ii/foo',
+    'j', 'j/bar', 'j/foo', 'jj', 'jj/bar', 'jj/foo',
+    'k', 'k/bar', 'k/foo', 'kk', 'kk/bar', 'kk/foo',
+    'l', 'l/bar', 'l/foo', 'll', 'll/bar', 'll/foo',
+    'm', 'm/bar', 'm/foo', 'mm', 'mm/bar', 'mm/foo',
+    'n', 'n/bar', 'n/foo', 'nn', 'nn/bar', 'nn/foo',
+    'o', 'o/bar', 'o/foo', 'oo', 'oo/bar', 'oo/foo',
+    'p', 'p/bar', 'p/foo', 'pp', 'pp/bar', 'pp/foo',
+    'q', 'q/bar', 'q/foo', 'qq', 'qq/bar', 'qq/foo',
+    'r', 'r/bar', 'r/foo', 'rr', 'rr/bar', 'rr/foo',
+    's', 's/bar', 's/foo', 'ss', 'ss/bar', 'ss/foo',
+    'symlinks', 'symlinks/symlink-src-dir', 'symlinks/symlink-src-file',
+    'symlinks/symlink-target-dir', 'symlinks/symlink-target-file',
+    't', 't/bar', 't/foo', 'tt', 'tt/bar', 'tt/foo',
+    'u', 'u/bar', 'u/foo', 'uu', 'uu/bar', 'uu/foo',
+    'v', 'v/bar', 'v/foo', 'vv', 'vv/bar', 'vv/foo',
+    'w', 'w/bar', 'w/foo', 'ww', 'ww/bar', 'ww/foo',
+    'x', 'x/bar', 'x/foo', 'xx', 'xx/bar', 'xx/foo',
+    'y', 'y/bar', 'y/foo', 'yy', 'yy/bar', 'yy/foo',
+    'z', 'z/bar', 'z/foo', 'zz', 'zz/bar', 'zz/foo',
+  ],
+  [
+    'a', 'a/bar', 'a/foo', 'aa', 'aa/bar', 'aa/foo',
+    'abc', 'abc/def', 'abc/def/bar',
+    'abc/def/foo', 'abc/ghi',
+    'b', 'b/bar', 'b/foo', 'bb', 'bb/bar', 'bb/foo',
+    'c', 'c/bar', 'c/foo', 'cc', 'cc/bar', 'cc/foo',
+    'd', 'd/bar', 'd/foo', 'dd', 'dd/bar', 'dd/foo',
+    'e', 'e/bar', 'e/foo', 'ee', 'ee/bar', 'ee/foo',
+    'f', 'f/bar', 'f/foo', 'ff', 'ff/bar', 'ff/foo',
+    'g', 'g/bar', 'g/foo', 'gg', 'gg/bar', 'gg/foo',
+    'h', 'h/bar', 'h/foo', 'hh', 'hh/bar', 'hh/foo',
+    'i', 'i/bar', 'i/foo', 'ii', 'ii/bar', 'ii/foo',
+    'j', 'j/bar', 'j/foo', 'jj', 'jj/bar', 'jj/foo',
+    'k', 'k/bar', 'k/foo', 'kk', 'kk/bar', 'kk/foo',
+    'l', 'l/bar', 'l/foo', 'll', 'll/bar', 'll/foo',
+    'm', 'm/bar', 'm/foo', 'mm', 'mm/bar', 'mm/foo',
+    'n', 'n/bar', 'n/foo', 'nn', 'nn/bar', 'nn/foo',
+    'o', 'o/bar', 'o/foo', 'oo', 'oo/bar', 'oo/foo',
+    'p', 'p/bar', 'p/foo', 'pp', 'pp/bar', 'pp/foo',
+    'q', 'q/bar', 'q/foo', 'qq', 'qq/bar', 'qq/foo',
+    'r', 'r/bar', 'r/foo', 'rr', 'rr/bar', 'rr/foo',
+    's', 's/bar', 's/foo', 'ss', 'ss/bar', 'ss/foo',
+    'symlinks', 'symlinks/symlink-src-dir', 'symlinks/symlink-src-file',
+    'symlinks/symlink-target-dir', 'symlinks/symlink-target-file',
+    't', 't/bar', 't/foo', 'tt', 'tt/bar', 'tt/foo',
+    'u', 'u/bar', 'u/foo', 'uu', 'uu/bar', 'uu/foo',
+    'v', 'v/bar', 'v/foo', 'vv', 'vv/bar', 'vv/foo',
+    'w', 'w/bar', 'w/foo', 'ww', 'ww/bar', 'ww/foo',
+    'x', 'x/bar', 'x/foo', 'xx', 'xx/bar', 'xx/foo',
+    'y', 'y/bar', 'y/foo', 'yy', 'yy/bar', 'yy/foo',
+    'z', 'z/bar', 'z/foo', 'zz', 'zz/bar', 'zz/foo',
+  ],
+];
+
 createFiles(readdirDir, fileStructure);
 const symlinksRootPath = pathModule.join(readdirDir, 'symlinks');
 const symlinkTargetFile = pathModule.join(symlinksRootPath, 'symlink-target-file');
@@ -86,61 +217,36 @@ const symlinkTargetDir = pathModule.join(symlinksRootPath, 'symlink-target-dir')
 fs.mkdirSync(symlinksRootPath);
 fs.writeFileSync(symlinkTargetFile, '');
 fs.mkdirSync(symlinkTargetDir);
-fs.symlinkSync(symlinkTargetFile, pathModule.join(symlinksRootPath, 'symlink-src-file'));
-fs.symlinkSync(symlinkTargetDir, pathModule.join(symlinksRootPath, 'symlink-src-dir'));
-
-const expected = [
-  'a', 'a/a', 'a/bar', 'a/foo', 'aa', 'aa/bar', 'aa/foo',
-  'abc', 'abc/def', 'abc/def/bar', 'abc/def/foo', 'abc/ghi', 'abc/ghi/bar', 'abc/ghi/foo',
-  'b', 'b/bar', 'b/foo', 'bb', 'bb/bar', 'bb/foo',
-  'c', 'c/bar', 'c/foo', 'cc', 'cc/bar', 'cc/foo',
-  'd', 'd/bar', 'd/foo', 'dd', 'dd/bar', 'dd/foo',
-  'e', 'e/bar', 'e/foo', 'ee', 'ee/bar', 'ee/foo',
-  'f', 'f/bar', 'f/foo', 'ff', 'ff/bar', 'ff/foo',
-  'g', 'g/bar', 'g/foo', 'gg', 'gg/bar', 'gg/foo',
-  'h', 'h/bar', 'h/foo', 'hh', 'hh/bar', 'hh/foo',
-  'i', 'i/bar', 'i/foo', 'ii', 'ii/bar', 'ii/foo',
-  'j', 'j/bar', 'j/foo', 'jj', 'jj/bar', 'jj/foo',
-  'k', 'k/bar', 'k/foo', 'kk', 'kk/bar', 'kk/foo',
-  'l', 'l/bar', 'l/foo', 'll', 'll/bar', 'll/foo',
-  'm', 'm/bar', 'm/foo', 'mm', 'mm/bar', 'mm/foo',
-  'n', 'n/bar', 'n/foo', 'nn', 'nn/bar', 'nn/foo',
-  'o', 'o/bar', 'o/foo', 'oo', 'oo/bar', 'oo/foo',
-  'p', 'p/bar', 'p/foo', 'pp', 'pp/bar', 'pp/foo',
-  'q', 'q/bar', 'q/foo', 'qq', 'qq/bar', 'qq/foo',
-  'r', 'r/bar', 'r/foo', 'rr', 'rr/bar', 'rr/foo',
-  's', 's/bar', 's/foo', 'ss', 'ss/bar', 'ss/foo',
-  'symlinks', 'symlinks/symlink-src-dir', 'symlinks/symlink-src-file',
-  'symlinks/symlink-target-dir', 'symlinks/symlink-target-file',
-  't', 't/bar', 't/foo', 'tt', 'tt/bar', 'tt/foo',
-  'u', 'u/bar', 'u/foo', 'uu', 'uu/bar', 'uu/foo',
-  'v', 'v/bar', 'v/foo', 'vv', 'vv/bar', 'vv/foo',
-  'w', 'w/bar', 'w/foo', 'ww', 'ww/bar', 'ww/foo',
-  'x', 'x/bar', 'x/foo', 'xx', 'xx/bar', 'xx/foo',
-  'y', 'y/bar', 'y/foo', 'yy', 'yy/bar', 'yy/foo',
-  'z', 'z/bar', 'z/foo', 'zz', 'zz/bar', 'zz/foo',
-];
+if (process.platform === 'win32') {
+  results.forEach(function(value) {
+    value.splice(value.indexOf('symlinks/symlink-src-dir'), 1);
+    value.splice(value.indexOf('symlinks/symlink-src-file'), 1);
+  });
+} else {
+  fs.symlinkSync(symlinkTargetFile, pathModule.join(symlinksRootPath, 'symlink-src-file'));
+  fs.symlinkSync(symlinkTargetDir, pathModule.join(symlinksRootPath, 'symlink-src-dir'));
+}
 
 // Normalize paths once for non POSIX platforms
-for (let i = 0; i < expected.length; i++) {
-  expected[i] = pathModule.normalize(expected[i]);
-}
+results.forEach(function(value) {
+  for (let i = 0; i < value.length; i++) {
+    value[i] = pathModule.normalize(value[i]);
+  }
+});
 
 function getDirentPath(dirent) {
   return pathModule.relative(readdirDir, pathModule.join(dirent.path, dirent.name));
 }
 
-function assertDirents(dirents) {
-  assert.strictEqual(dirents.length, expected.length);
+function assertDirents(dirents, index) {
+  const testCase = results[index];
+  assert.strictEqual(dirents.length, testCase.length);
   dirents.sort((a, b) => (getDirentPath(a) < getDirentPath(b) ? -1 : 1));
-  assert.deepStrictEqual(
-    dirents.map((dirent) => {
-      assert(dirent instanceof fs.Dirent);
-      assert.notStrictEqual(dirent.name, undefined);
-      return getDirentPath(dirent);
-    }),
-    expected
-  );
+  for (const [i, dirent] of dirents.entries()) {
+    assert(dirent instanceof fs.Dirent);
+    assert.notStrictEqual(dirent.name, undefined);
+    assert.strictEqual(getDirentPath(dirent), testCase[i]);
+  }
 }
 
 // readdirSync
@@ -148,30 +254,174 @@ function assertDirents(dirents) {
 // readdirSync { recursive }
 {
   const result = fs.readdirSync(readdirDir, { recursive: true });
-  assert.deepStrictEqual(result.sort(), expected);
+  assert.deepStrictEqual(result.sort(), results[0]);
+}
+
+// readdirSync { recursive: depth 1 }
+{
+  const result = fs.readdirSync(readdirDir, {
+    recursive: function(name, depth) {
+      return depth < 1;
+    }
+  });
+  assert.deepStrictEqual(result.sort(), results[1]);
+}
+
+// readdirSync { recursive: depth 2 }
+{
+  const result = fs.readdirSync(readdirDir, {
+    recursive: function(name, depth) {
+      return depth < 2;
+    }
+  });
+  assert.deepStrictEqual(result.sort(), results[2]);
+}
+
+// readdirSync { recursive: name 'def' }
+{
+  const result = fs.readdirSync(readdirDir, {
+    recursive: function(name, depth) {
+      return depth < 1 || (name.includes('def') && depth > 0);
+    }
+  });
+  assert.deepStrictEqual(result.sort(), results[3]);
 }
 
 // readdirSync { recursive, withFileTypes }
 {
-  const result = fs.readdirSync(readdirDir, { recursive: true, withFileTypes: true });
-  assertDirents(result);
+  const result = fs.readdirSync(readdirDir, {
+    recursive: true,
+    withFileTypes: true
+  });
+  assertDirents(result, 0);
+}
+
+// readdirSync { recursive: depth 1, withFileTypes }
+{
+  const result = fs.readdirSync(readdirDir, {
+    recursive: function(dirent, depth) {
+      return depth < 1;
+    },
+    withFileTypes: true
+  });
+  assertDirents(result, 1);
+}
+
+// readdirSync { recursive: depth 2, withFileTypes }
+{
+  const result = fs.readdirSync(readdirDir, {
+    recursive: function(dirent, depth) {
+      return depth < 2;
+    },
+    withFileTypes: true
+  });
+  assertDirents(result, 2);
+}
+
+// readdirSync { recursive: name 'def', withFileTypes }
+{
+  const result = fs.readdirSync(readdirDir, {
+    recursive: function(dirent, depth) {
+      return depth < 1 || (dirent.name.includes('def') && depth > 0);
+    },
+    withFileTypes: true
+  });
+  assertDirents(result, 3);
 }
 
 // readdir
 
-// readdir { recursive } callback
+// Readdir { recursive } callback
 {
   fs.readdir(readdirDir, { recursive: true },
              common.mustSucceed((result) => {
-               assert.deepStrictEqual(result.sort(), expected);
+               assert.deepStrictEqual(result.sort(), results[0]);
+             }));
+}
+
+// Readdir { recursive: depth 1 } callback
+{
+  fs.readdir(readdirDir, {
+    recursive: function(name, depth) {
+      return depth < 1;
+    }
+  },
+             common.mustSucceed((result) => {
+               assert.deepStrictEqual(result.sort(), results[1]);
+             }));
+}
+
+// Readdir { recursive: depth 2 } callback
+{
+  fs.readdir(readdirDir, {
+    recursive: function(name, depth) {
+      return depth < 2;
+    }
+  },
+             common.mustSucceed((result) => {
+               assert.deepStrictEqual(result.sort(), results[2]);
+             }));
+}
+
+// Readdir { recursive: name 'def' } callback
+{
+  fs.readdir(readdirDir, {
+    recursive: function(name, depth) {
+      return depth < 1 || (name.includes('def') && depth > 0);
+    }
+  },
+             common.mustSucceed((result) => {
+               assert.deepStrictEqual(result.sort(), results[3]);
              }));
 }
 
 // Readdir { recursive, withFileTypes } callback
 {
-  fs.readdir(readdirDir, { recursive: true, withFileTypes: true },
+  fs.readdir(readdirDir, {
+    recursive: true,
+    withFileTypes: true
+  },
              common.mustSucceed((result) => {
-               assertDirents(result);
+               assertDirents(result, 0);
+             }));
+}
+
+// Readdir { recursive: depth 1, withFileTypes } callback
+{
+  fs.readdir(readdirDir, {
+    recursive: function(dirent, depth) {
+      return depth < 1;
+    },
+    withFileTypes: true
+  },
+             common.mustSucceed((result) => {
+               assertDirents(result, 1);
+             }));
+}
+
+// Readdir { recursive: depth 2, withFileTypes } callback
+{
+  fs.readdir(readdirDir, {
+    recursive: function(dirent, depth) {
+      return depth < 2;
+    },
+    withFileTypes: true
+  },
+             common.mustSucceed((result) => {
+               assertDirents(result, 2);
+             }));
+}
+
+// Readdir { recursive: name 'def', withFileTypes } callback
+{
+  fs.readdir(readdirDir, {
+    recursive: function(dirent, depth) {
+      return depth < 1 || (dirent.name.includes('def') && depth > 0);
+    },
+    withFileTypes: true
+  },
+             common.mustSucceed((result) => {
+               assertDirents(result, 3);
              }));
 }
 
@@ -181,7 +431,49 @@ function assertDirents(dirents) {
 {
   async function test() {
     const result = await fs.promises.readdir(readdirDir, { recursive: true });
-    assert.deepStrictEqual(result.sort(), expected);
+    assert.deepStrictEqual(result.sort(), results[0]);
+  }
+
+  test().then(common.mustCall());
+}
+
+// fs.promises.readdir { recursive: depth 1 }
+{
+  async function test() {
+    const result = await fs.promises.readdir(readdirDir, {
+      recursive: function(name, depth) {
+        return depth < 1;
+      }
+    });
+    assert.deepStrictEqual(result.sort(), results[1]);
+  }
+
+  test().then(common.mustCall());
+}
+
+// fs.promises.readdir { recursive: depth 2 }
+{
+  async function test() {
+    const result = await fs.promises.readdir(readdirDir, {
+      recursive: function(name, depth) {
+        return depth < 2;
+      }
+    });
+    assert.deepStrictEqual(result.sort(), results[2]);
+  }
+
+  test().then(common.mustCall());
+}
+
+// fs.promises.readdir { recursive: name 'def' }
+{
+  async function test() {
+    const result = await fs.promises.readdir(readdirDir, {
+      recursive: function(name, depth) {
+        return depth < 1 || (name.includes('def') && depth > 0);
+      }
+    });
+    assert.deepStrictEqual(result.sort(), results[3]);
   }
 
   test().then(common.mustCall());
@@ -190,8 +482,56 @@ function assertDirents(dirents) {
 // fs.promises.readdir { recursive, withFileTypes }
 {
   async function test() {
-    const result = await fs.promises.readdir(readdirDir, { recursive: true, withFileTypes: true });
-    assertDirents(result);
+    const result = await fs.promises.readdir(readdirDir, {
+      recursive: true,
+      withFileTypes: true
+    });
+    assertDirents(result, 0);
+  }
+
+  test().then(common.mustCall());
+}
+
+// fs.promises.readdir { recursive: depth 1, withFileTypes }
+{
+  async function test() {
+    const result = await fs.promises.readdir(readdirDir, {
+      recursive: function(dirent, depth) {
+        return depth < 1;
+      },
+      withFileTypes: true
+    });
+    assertDirents(result, 1);
+  }
+
+  test().then(common.mustCall());
+}
+
+// fs.promises.readdir { recursive: depth 2, withFileTypes }
+{
+  async function test() {
+    const result = await fs.promises.readdir(readdirDir, {
+      recursive: function(dirent, depth) {
+        return depth < 2;
+      },
+      withFileTypes: true
+    });
+    assertDirents(result, 2);
+  }
+
+  test().then(common.mustCall());
+}
+
+// fs.promises.readdir { recursive: name 'def', withFileTypes }
+{
+  async function test() {
+    const result = await fs.promises.readdir(readdirDir, {
+      recursive: function(dirent, depth) {
+        return depth < 1 || (dirent.name.includes('def') && depth > 0);
+      },
+      withFileTypes: true
+    });
+    assertDirents(result, 3);
   }
 
   test().then(common.mustCall());