diff --git a/doc/api/assert.md b/doc/api/assert.md
index cbb8446b5d5444..45f889712e6513 100644
--- a/doc/api/assert.md
+++ b/doc/api/assert.md
@@ -149,6 +149,8 @@ added: v0.1.21
   * `operator` {string} The `operator` property on the error instance.
   * `stackStartFn` {Function} If provided, the generated stack trace omits
     frames before this function.
+  * `diff` {string} If set to `'full'`, shows the full diff in assertion errors. Defaults to `'simple'`.
+    Accepted values: `'simple'`, `'full'`.
 
 A subclass of {Error} that indicates the failure of an assertion.
 
@@ -215,6 +217,31 @@ try {
 }
 ```
 
+## Class: assert.Assert
+
+<!-- YAML
+added: REPLACEME
+-->
+
+The `Assert` class allows creating independent assertion instances with custom options.
+
+### `new assert.Assert([options])`
+
+* `options` {Object}
+  * `diff` {string} If set to `'full'`, shows the full diff in assertion errors. Defaults to `'simple'`.
+    Accepted values: `'simple'`, `'full'`.
+  * `strict` {boolean} If set to `true`, non-strict methods behave like their
+    corresponding strict methods. Defaults to `true`.
+
+Creates a new assertion instance. The `diff` option controls the verbosity of diffs in assertion error messages.
+
+```js
+const { Assert } = require('node:assert');
+const assertInstance = new Assert({ diff: 'full' });
+assertInstance.deepStrictEqual({ a: 1 }, { a: 2 });
+// Shows a full diff in the error message.
+```
+
 ## `assert(value[, message])`
 
 <!-- YAML
diff --git a/lib/assert.js b/lib/assert.js
index 6dedcd0b971046..73359c953cb4c0 100644
--- a/lib/assert.js
+++ b/lib/assert.js
@@ -28,6 +28,7 @@ const {
   Error,
   NumberIsNaN,
   ObjectAssign,
+  ObjectDefineProperty,
   ObjectIs,
   ObjectKeys,
   ObjectPrototypeIsPrototypeOf,
@@ -37,6 +38,7 @@ const {
   StringPrototypeIndexOf,
   StringPrototypeSlice,
   StringPrototypeSplit,
+  Symbol,
 } = primordials;
 
 const {
@@ -61,6 +63,8 @@ const {
   validateFunction,
 } = require('internal/validators');
 
+const kOptions = Symbol('options');
+
 let isDeepEqual;
 let isDeepStrictEqual;
 let isPartialStrictEqual;
@@ -80,6 +84,55 @@ const assert = module.exports = ok;
 
 const NO_EXCEPTION_SENTINEL = {};
 
+/**
+ * Assert options.
+ * @typedef {object} AssertOptions
+ * @property {'full'|'simple'} [diff='simple'] - If set to 'full', shows the full diff in assertion errors.
+ * @property {boolean} [strict=true] - If set to true, non-strict methods behave like their corresponding
+ *   strict methods.
+ */
+
+/**
+ * @class Assert
+ * @param {AssertOptions} [options] - Optional configuration for assertions.
+ * @throws {ERR_INVALID_ARG_TYPE} If not called with `new`.
+ */
+function Assert(options) {
+  if (!new.target) {
+    throw new ERR_INVALID_ARG_TYPE('Assert', 'constructor', Assert);
+  }
+
+  options = ObjectAssign({ strict: true }, options);
+
+  const allowedDiffs = ['simple', 'full'];
+  if (
+    options.diff !== undefined &&
+    !allowedDiffs.includes(options.diff)
+  ) {
+    throw new ERR_INVALID_ARG_VALUE(
+      'options.diff',
+      options.diff,
+      `must be one of ${allowedDiffs.map((d) => `"${d}"`).join(', ')}`,
+    );
+  }
+
+  this.AssertionError = AssertionError;
+  ObjectDefineProperty(this, kOptions, {
+    __proto__: null,
+    value: options,
+    enumerable: false,
+    configurable: false,
+    writable: false,
+  });
+
+  if (options.strict) {
+    this.equal = this.strictEqual;
+    this.deepEqual = this.deepStrictEqual;
+    this.notEqual = this.notStrictEqual;
+    this.notDeepEqual = this.notDeepStrictEqual;
+  }
+}
+
 // All of the following functions must throw an AssertionError
 // when a corresponding condition is not met, with a message that
 // may be undefined if not provided. All assertion methods provide
@@ -96,7 +149,7 @@ function innerFail(obj) {
  * Throws an AssertionError with the given message.
  * @param {any | Error} [message]
  */
-function fail(message) {
+Assert.prototype.fail = function fail(message) {
   if (isError(message)) throw message;
 
   let internalMessage = false;
@@ -109,15 +162,14 @@ function fail(message) {
     operator: 'fail',
     stackStartFn: fail,
     message,
+    diff: this?.[kOptions]?.diff,
   };
   const err = new AssertionError(errArgs);
   if (internalMessage) {
     err.generatedMessage = true;
   }
   throw err;
-}
-
-assert.fail = fail;
+};
 
 // The AssertionError is defined in internal/error.
 assert.AssertionError = AssertionError;
@@ -131,6 +183,7 @@ assert.AssertionError = AssertionError;
 function ok(...args) {
   innerOk(ok, args.length, ...args);
 }
+Assert.prototype.ok = ok;
 assert.ok = ok;
 
 /**
@@ -140,8 +193,7 @@ assert.ok = ok;
  * @param {string | Error} [message]
  * @returns {void}
  */
-/* eslint-disable no-restricted-properties */
-assert.equal = function equal(actual, expected, message) {
+Assert.prototype.equal = function equal(actual, expected, message) {
   if (arguments.length < 2) {
     throw new ERR_MISSING_ARGS('actual', 'expected');
   }
@@ -153,6 +205,7 @@ assert.equal = function equal(actual, expected, message) {
       message,
       operator: '==',
       stackStartFn: equal,
+      diff: this?.[kOptions]?.diff,
     });
   }
 };
@@ -165,7 +218,7 @@ assert.equal = function equal(actual, expected, message) {
  * @param {string | Error} [message]
  * @returns {void}
  */
-assert.notEqual = function notEqual(actual, expected, message) {
+Assert.prototype.notEqual = function notEqual(actual, expected, message) {
   if (arguments.length < 2) {
     throw new ERR_MISSING_ARGS('actual', 'expected');
   }
@@ -177,6 +230,7 @@ assert.notEqual = function notEqual(actual, expected, message) {
       message,
       operator: '!=',
       stackStartFn: notEqual,
+      diff: this?.[kOptions]?.diff,
     });
   }
 };
@@ -188,7 +242,7 @@ assert.notEqual = function notEqual(actual, expected, message) {
  * @param {string | Error} [message]
  * @returns {void}
  */
-assert.deepEqual = function deepEqual(actual, expected, message) {
+Assert.prototype.deepEqual = function deepEqual(actual, expected, message) {
   if (arguments.length < 2) {
     throw new ERR_MISSING_ARGS('actual', 'expected');
   }
@@ -200,6 +254,7 @@ assert.deepEqual = function deepEqual(actual, expected, message) {
       message,
       operator: 'deepEqual',
       stackStartFn: deepEqual,
+      diff: this?.[kOptions]?.diff,
     });
   }
 };
@@ -211,7 +266,7 @@ assert.deepEqual = function deepEqual(actual, expected, message) {
  * @param {string | Error} [message]
  * @returns {void}
  */
-assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
+Assert.prototype.notDeepEqual = function notDeepEqual(actual, expected, message) {
   if (arguments.length < 2) {
     throw new ERR_MISSING_ARGS('actual', 'expected');
   }
@@ -223,10 +278,10 @@ assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
       message,
       operator: 'notDeepEqual',
       stackStartFn: notDeepEqual,
+      diff: this?.[kOptions]?.diff,
     });
   }
 };
-/* eslint-enable */
 
 /**
  * The deep strict equivalence assertion tests a deep strict equality
@@ -236,7 +291,7 @@ assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
  * @param {string | Error} [message]
  * @returns {void}
  */
-assert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {
+Assert.prototype.deepStrictEqual = function deepStrictEqual(actual, expected, message) {
   if (arguments.length < 2) {
     throw new ERR_MISSING_ARGS('actual', 'expected');
   }
@@ -248,6 +303,7 @@ assert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {
       message,
       operator: 'deepStrictEqual',
       stackStartFn: deepStrictEqual,
+      diff: this?.[kOptions]?.diff,
     });
   }
 };
@@ -260,7 +316,7 @@ assert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {
  * @param {string | Error} [message]
  * @returns {void}
  */
-assert.notDeepStrictEqual = notDeepStrictEqual;
+Assert.prototype.notDeepStrictEqual = notDeepStrictEqual;
 function notDeepStrictEqual(actual, expected, message) {
   if (arguments.length < 2) {
     throw new ERR_MISSING_ARGS('actual', 'expected');
@@ -273,6 +329,7 @@ function notDeepStrictEqual(actual, expected, message) {
       message,
       operator: 'notDeepStrictEqual',
       stackStartFn: notDeepStrictEqual,
+      diff: this?.[kOptions]?.diff,
     });
   }
 }
@@ -284,7 +341,7 @@ function notDeepStrictEqual(actual, expected, message) {
  * @param {string | Error} [message]
  * @returns {void}
  */
-assert.strictEqual = function strictEqual(actual, expected, message) {
+Assert.prototype.strictEqual = function strictEqual(actual, expected, message) {
   if (arguments.length < 2) {
     throw new ERR_MISSING_ARGS('actual', 'expected');
   }
@@ -295,6 +352,7 @@ assert.strictEqual = function strictEqual(actual, expected, message) {
       message,
       operator: 'strictEqual',
       stackStartFn: strictEqual,
+      diff: this?.[kOptions]?.diff,
     });
   }
 };
@@ -306,7 +364,7 @@ assert.strictEqual = function strictEqual(actual, expected, message) {
  * @param {string | Error} [message]
  * @returns {void}
  */
-assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
+Assert.prototype.notStrictEqual = function notStrictEqual(actual, expected, message) {
   if (arguments.length < 2) {
     throw new ERR_MISSING_ARGS('actual', 'expected');
   }
@@ -317,6 +375,7 @@ assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
       message,
       operator: 'notStrictEqual',
       stackStartFn: notStrictEqual,
+      diff: this?.[kOptions]?.diff,
     });
   }
 };
@@ -328,7 +387,7 @@ assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
  * @param {string | Error} [message]
  * @returns {void}
  */
-assert.partialDeepStrictEqual = function partialDeepStrictEqual(
+Assert.prototype.partialDeepStrictEqual = function partialDeepStrictEqual(
   actual,
   expected,
   message,
@@ -344,6 +403,7 @@ assert.partialDeepStrictEqual = function partialDeepStrictEqual(
       message,
       operator: 'partialDeepStrictEqual',
       stackStartFn: partialDeepStrictEqual,
+      diff: this?.[kOptions]?.diff,
     });
   }
 };
@@ -377,6 +437,7 @@ function compareExceptionKey(actual, expected, key, message, keys, fn) {
         expected: b,
         operator: 'deepStrictEqual',
         stackStartFn: fn,
+        diff: this?.[kOptions]?.diff,
       });
       err.actual = actual;
       err.expected = expected;
@@ -389,6 +450,7 @@ function compareExceptionKey(actual, expected, key, message, keys, fn) {
       message,
       operator: fn.name,
       stackStartFn: fn,
+      diff: this?.[kOptions]?.diff,
     });
   }
 }
@@ -418,6 +480,7 @@ function expectedException(actual, expected, message, fn) {
         message,
         operator: 'deepStrictEqual',
         stackStartFn: fn,
+        diff: this?.[kOptions]?.diff,
       });
       err.operator = fn.name;
       throw err;
@@ -493,6 +556,7 @@ function expectedException(actual, expected, message, fn) {
       message,
       operator: fn.name,
       stackStartFn: fn,
+      diff: this?.[kOptions]?.diff,
     });
     err.generatedMessage = generatedMessage;
     throw err;
@@ -580,20 +644,21 @@ function expectsError(stackStartFn, actual, error, message) {
       details += ` (${error.name})`;
     }
     details += message ? `: ${message}` : '.';
-    const fnType = stackStartFn === assert.rejects ? 'rejection' : 'exception';
+    const fnType = stackStartFn === Assert.prototype.rejects ? 'rejection' : 'exception';
     innerFail({
       actual: undefined,
       expected: error,
       operator: stackStartFn.name,
       message: `Missing expected ${fnType}${details}`,
       stackStartFn,
+      diff: this?.[kOptions]?.diff,
     });
   }
 
   if (!error)
     return;
 
-  expectedException(actual, error, message, stackStartFn);
+  expectedException.call(this, actual, error, message, stackStartFn);
 }
 
 function hasMatchingError(actual, expected) {
@@ -627,7 +692,7 @@ function expectsNoError(stackStartFn, actual, error, message) {
 
   if (!error || hasMatchingError(actual, error)) {
     const details = message ? `: ${message}` : '.';
-    const fnType = stackStartFn === assert.doesNotReject ?
+    const fnType = stackStartFn === Assert.prototype.doesNotReject ?
       'rejection' : 'exception';
     innerFail({
       actual,
@@ -636,6 +701,7 @@ function expectsNoError(stackStartFn, actual, error, message) {
       message: `Got unwanted ${fnType}${details}\n` +
                `Actual message: "${actual?.message}"`,
       stackStartFn,
+      diff: this?.[kOptions]?.diff,
     });
   }
   throw actual;
@@ -647,7 +713,7 @@ function expectsNoError(stackStartFn, actual, error, message) {
  * @param {...any} [args]
  * @returns {void}
  */
-assert.throws = function throws(promiseFn, ...args) {
+Assert.prototype.throws = function throws(promiseFn, ...args) {
   expectsError(throws, getActual(promiseFn), ...args);
 };
 
@@ -657,7 +723,7 @@ assert.throws = function throws(promiseFn, ...args) {
  * @param {...any} [args]
  * @returns {Promise<void>}
  */
-assert.rejects = async function rejects(promiseFn, ...args) {
+Assert.prototype.rejects = async function rejects(promiseFn, ...args) {
   expectsError(rejects, await waitForActual(promiseFn), ...args);
 };
 
@@ -667,7 +733,7 @@ assert.rejects = async function rejects(promiseFn, ...args) {
  * @param {...any} [args]
  * @returns {void}
  */
-assert.doesNotThrow = function doesNotThrow(fn, ...args) {
+Assert.prototype.doesNotThrow = function doesNotThrow(fn, ...args) {
   expectsNoError(doesNotThrow, getActual(fn), ...args);
 };
 
@@ -677,7 +743,7 @@ assert.doesNotThrow = function doesNotThrow(fn, ...args) {
  * @param {...any} [args]
  * @returns {Promise<void>}
  */
-assert.doesNotReject = async function doesNotReject(fn, ...args) {
+Assert.prototype.doesNotReject = async function doesNotReject(fn, ...args) {
   expectsNoError(doesNotReject, await waitForActual(fn), ...args);
 };
 
@@ -686,7 +752,7 @@ assert.doesNotReject = async function doesNotReject(fn, ...args) {
  * @param {any} err
  * @returns {void}
  */
-assert.ifError = function ifError(err) {
+Assert.prototype.ifError = function ifError(err) {
   if (err !== null && err !== undefined) {
     let message = 'ifError got unwanted exception: ';
     if (typeof err === 'object' && typeof err.message === 'string') {
@@ -705,6 +771,7 @@ assert.ifError = function ifError(err) {
       operator: 'ifError',
       message,
       stackStartFn: ifError,
+      diff: this?.[kOptions]?.diff,
     });
 
     // Make sure we actually have a stack trace!
@@ -747,7 +814,7 @@ function internalMatch(string, regexp, message, fn) {
       'regexp', 'RegExp', regexp,
     );
   }
-  const match = fn === assert.match;
+  const match = fn === Assert.prototype.match;
   if (typeof string !== 'string' ||
       RegExpPrototypeExec(regexp, string) !== null !== match) {
     if (message instanceof Error) {
@@ -770,6 +837,7 @@ function internalMatch(string, regexp, message, fn) {
       message,
       operator: fn.name,
       stackStartFn: fn,
+      diff: this?.[kOptions]?.diff,
     });
     err.generatedMessage = generatedMessage;
     throw err;
@@ -783,7 +851,7 @@ function internalMatch(string, regexp, message, fn) {
  * @param {string | Error} [message]
  * @returns {void}
  */
-assert.match = function match(string, regexp, message) {
+Assert.prototype.match = function match(string, regexp, message) {
   internalMatch(string, regexp, message, match);
 };
 
@@ -794,7 +862,7 @@ assert.match = function match(string, regexp, message) {
  * @param {string | Error} [message]
  * @returns {void}
  */
-assert.doesNotMatch = function doesNotMatch(string, regexp, message) {
+Assert.prototype.doesNotMatch = function doesNotMatch(string, regexp, message) {
   internalMatch(string, regexp, message, doesNotMatch);
 };
 
@@ -807,6 +875,18 @@ function strict(...args) {
   innerOk(strict, args.length, ...args);
 }
 
+const assertInstance = new Assert({ diff: 'simple', strict: false });
+[
+  'ok', 'fail', 'equal', 'notEqual', 'deepEqual', 'notDeepEqual',
+  'deepStrictEqual', 'notDeepStrictEqual', 'strictEqual',
+  'notStrictEqual', 'partialDeepStrictEqual', 'match', 'doesNotMatch',
+  'throws', 'rejects', 'doesNotThrow', 'doesNotReject', 'ifError',
+].forEach((name) => {
+  const bound = assertInstance[name].bind(assertInstance);
+  ObjectDefineProperty(bound, 'name', { __proto__: null, value: name });
+  assert[name] = bound;
+});
+
 assert.strict = ObjectAssign(strict, assert, {
   equal: assert.strictEqual,
   deepEqual: assert.deepStrictEqual,
@@ -814,4 +894,7 @@ assert.strict = ObjectAssign(strict, assert, {
   notDeepEqual: assert.notDeepStrictEqual,
 });
 
+assert.strict.Assert = Assert;
 assert.strict.strict = assert.strict;
+
+module.exports.Assert = Assert;
diff --git a/lib/internal/assert/assertion_error.js b/lib/internal/assert/assertion_error.js
index d654ca5038bbab..5c15b96b12d1ea 100644
--- a/lib/internal/assert/assertion_error.js
+++ b/lib/internal/assert/assertion_error.js
@@ -178,7 +178,7 @@ function isSimpleDiff(actual, inspectedActual, expected, inspectedExpected) {
   return typeof actual !== 'object' || actual === null || typeof expected !== 'object' || expected === null;
 }
 
-function createErrDiff(actual, expected, operator, customMessage) {
+function createErrDiff(actual, expected, operator, customMessage, diffType = 'simple') {
   operator = checkOperator(actual, expected, operator);
 
   let skipped = false;
@@ -202,7 +202,7 @@ function createErrDiff(actual, expected, operator, customMessage) {
   } else if (inspectedActual === inspectedExpected) {
     // Handles the case where the objects are structurally the same but different references
     operator = 'notIdentical';
-    if (inspectedSplitActual.length > 50) {
+    if (inspectedSplitActual.length > 50 && diffType !== 'full') {
       message = `${ArrayPrototypeJoin(ArrayPrototypeSlice(inspectedSplitActual, 0, 50), '\n')}\n...}`;
       skipped = true;
     } else {
@@ -252,6 +252,7 @@ class AssertionError extends Error {
       details,
       // Compatibility with older versions.
       stackStartFunction,
+      diff = 'simple',
     } = options;
     let {
       actual,
@@ -263,7 +264,7 @@ class AssertionError extends Error {
 
     if (message != null) {
       if (kMethodsWithCustomMessageDiff.includes(operator)) {
-        super(createErrDiff(actual, expected, operator, message));
+        super(createErrDiff(actual, expected, operator, message, diff));
       } else {
         super(String(message));
       }
@@ -283,7 +284,7 @@ class AssertionError extends Error {
       }
 
       if (kMethodsWithCustomMessageDiff.includes(operator)) {
-        super(createErrDiff(actual, expected, operator, message));
+        super(createErrDiff(actual, expected, operator, message, diff));
       } else if (operator === 'notDeepStrictEqual' ||
         operator === 'notStrictEqual') {
         // In case the objects are equal but the operator requires unequal, show
@@ -300,8 +301,7 @@ class AssertionError extends Error {
         }
 
         // Only remove lines in case it makes sense to collapse those.
-        // TODO: Accept env to always show the full error.
-        if (res.length > 50) {
+        if (res.length > 50 && diff !== 'full') {
           res[46] = `${colors.blue}...${colors.white}`;
           while (res.length > 47) {
             ArrayPrototypePop(res);
@@ -320,15 +320,15 @@ class AssertionError extends Error {
         const knownOperator = kReadableOperator[operator];
         if (operator === 'notDeepEqual' && res === other) {
           res = `${knownOperator}\n\n${res}`;
-          if (res.length > 1024) {
+          if (res.length > 1024 && diff !== 'full') {
             res = `${StringPrototypeSlice(res, 0, 1021)}...`;
           }
           super(res);
         } else {
-          if (res.length > kMaxLongStringLength) {
+          if (res.length > kMaxLongStringLength && diff !== 'full') {
             res = `${StringPrototypeSlice(res, 0, 509)}...`;
           }
-          if (other.length > kMaxLongStringLength) {
+          if (other.length > kMaxLongStringLength && diff !== 'full') {
             other = `${StringPrototypeSlice(other, 0, 509)}...`;
           }
           if (operator === 'deepEqual') {
@@ -378,6 +378,7 @@ class AssertionError extends Error {
     this.stack; // eslint-disable-line no-unused-expressions
     // Reset the name.
     this.name = 'AssertionError';
+    this.diff = diff;
   }
 
   toString() {
diff --git a/test/fixtures/errors/error_exit.snapshot b/test/fixtures/errors/error_exit.snapshot
index 778165dc25c4fc..9594e08b4dadf9 100644
--- a/test/fixtures/errors/error_exit.snapshot
+++ b/test/fixtures/errors/error_exit.snapshot
@@ -12,7 +12,8 @@ AssertionError [ERR_ASSERTION]: Expected values to be strictly equal:
   code: 'ERR_ASSERTION',
   actual: 1,
   expected: 2,
-  operator: 'strictEqual'
+  operator: 'strictEqual',
+  diff: 'simple'
 }
 
 Node.js *
diff --git a/test/fixtures/errors/if-error-has-good-stack.snapshot b/test/fixtures/errors/if-error-has-good-stack.snapshot
index 9296b25f10b7c6..ba76800b970028 100644
--- a/test/fixtures/errors/if-error-has-good-stack.snapshot
+++ b/test/fixtures/errors/if-error-has-good-stack.snapshot
@@ -19,7 +19,8 @@ AssertionError [ERR_ASSERTION]: ifError got unwanted exception: test error
       at a (*if-error-has-good-stack.js:*:*)
       at Object.<anonymous> (*if-error-has-good-stack.js:*:*),
   expected: null,
-  operator: 'ifError'
+  operator: 'ifError',
+  diff: 'simple'
 }
 
 Node.js *
diff --git a/test/fixtures/test-runner/output/assertion-color-tty.snapshot b/test/fixtures/test-runner/output/assertion-color-tty.snapshot
index a74016febc5df4..4409d6f5e3e939 100644
--- a/test/fixtures/test-runner/output/assertion-color-tty.snapshot
+++ b/test/fixtures/test-runner/output/assertion-color-tty.snapshot
@@ -21,5 +21,6 @@
     code: [32m'ERR_ASSERTION'[39m,
     actual: [32m'!Hello World'[39m,
     expected: [32m'Hello World!'[39m,
-    operator: [32m'strictEqual'[39m
+    operator: [32m'strictEqual'[39m,
+    diff: [32m'simple'[39m
   }
diff --git a/test/fixtures/test-runner/output/dot_reporter.snapshot b/test/fixtures/test-runner/output/dot_reporter.snapshot
index 4ef804951dc99f..c50cb99c16a0fa 100644
--- a/test/fixtures/test-runner/output/dot_reporter.snapshot
+++ b/test/fixtures/test-runner/output/dot_reporter.snapshot
@@ -66,7 +66,8 @@ Failed tests:
     code: 'ERR_ASSERTION',
     actual: true,
     expected: false,
-    operator: 'strictEqual'
+    operator: 'strictEqual',
+    diff: 'simple'
   }
 ✖ reject fail (*ms)
   Error: rejected from reject fail
@@ -215,7 +216,8 @@ Failed tests:
     code: 'ERR_ASSERTION',
     actual: [Object],
     expected: [Object],
-    operator: 'deepEqual'
+    operator: 'deepEqual',
+    diff: 'simple'
   }
 ✖ invalid subtest fail (*ms)
   'test could not be started because its parent finished'
diff --git a/test/fixtures/test-runner/output/junit_reporter.snapshot b/test/fixtures/test-runner/output/junit_reporter.snapshot
index d1868bd4b6eaa9..37cea45d62bd84 100644
--- a/test/fixtures/test-runner/output/junit_reporter.snapshot
+++ b/test/fixtures/test-runner/output/junit_reporter.snapshot
@@ -124,7 +124,8 @@ true !== false
     code: 'ERR_ASSERTION',
     actual: true,
     expected: false,
-    operator: 'strictEqual'
+    operator: 'strictEqual',
+    diff: 'simple'
   }
 }
 		</failure>
@@ -491,7 +492,8 @@ should loosely deep-equal
     code: 'ERR_ASSERTION',
     actual: [Object],
     expected: [Object],
-    operator: 'deepEqual'
+    operator: 'deepEqual',
+    diff: 'simple'
   }
 }
 		</failure>
diff --git a/test/fixtures/test-runner/output/spec_reporter.snapshot b/test/fixtures/test-runner/output/spec_reporter.snapshot
index 17eb9d01451d32..749f0dce43a450 100644
--- a/test/fixtures/test-runner/output/spec_reporter.snapshot
+++ b/test/fixtures/test-runner/output/spec_reporter.snapshot
@@ -171,7 +171,8 @@
     code: 'ERR_ASSERTION',
     actual: true,
     expected: false,
-    operator: 'strictEqual'
+    operator: 'strictEqual',
+    diff: 'simple'
   }
 
 *
@@ -356,7 +357,8 @@
     code: 'ERR_ASSERTION',
     actual: [Object],
     expected: [Object],
-    operator: 'deepEqual'
+    operator: 'deepEqual',
+    diff: 'simple'
   }
 
 *
diff --git a/test/fixtures/test-runner/output/spec_reporter_cli.snapshot b/test/fixtures/test-runner/output/spec_reporter_cli.snapshot
index 2dd9e92deb1b38..b3a352092c677a 100644
--- a/test/fixtures/test-runner/output/spec_reporter_cli.snapshot
+++ b/test/fixtures/test-runner/output/spec_reporter_cli.snapshot
@@ -174,7 +174,8 @@
     code: 'ERR_ASSERTION',
     actual: true,
     expected: false,
-    operator: 'strictEqual'
+    operator: 'strictEqual',
+    diff: 'simple'
   }
 
 *
@@ -359,7 +360,8 @@
     code: 'ERR_ASSERTION',
     actual: { foo: 1, bar: 1, boo: [ 1 ], baz: { date: 1970-01-01T00:00:00.000Z, null: null, number: 1, string: 'Hello', undefined: undefined } },
     expected: { boo: [ 1 ], baz: { date: 1970-01-01T00:00:00.000Z, null: null, number: 1, string: 'Hello', undefined: undefined }, circular: <ref *1> { bar: 2, c: [Circular *1] } },
-    operator: 'deepEqual'
+    operator: 'deepEqual',
+    diff: 'simple'
   }
 
 *
diff --git a/test/message/assert_throws_stack.out b/test/message/assert_throws_stack.out
index 897ddf36a04eb0..7cb062c3f91cd7 100644
--- a/test/message/assert_throws_stack.out
+++ b/test/message/assert_throws_stack.out
@@ -9,6 +9,7 @@ AssertionError [ERR_ASSERTION]: Expected values to be strictly deep-equal:
 - Comparison {
 -   bar: true
 - }
+
     at Object.<anonymous> (*assert_throws_stack.js:*:*)
     at *
     at *
@@ -23,7 +24,7 @@ AssertionError [ERR_ASSERTION]: Expected values to be strictly deep-equal:
   actual: Error: foo
       at assert.throws.bar (*assert_throws_stack.js:*)
       at getActual (node:assert:*)
-      at strict.throws (node:assert:*)
+      at Assert.throws (node:assert:*)
       at Object.<anonymous> (*assert_throws_stack.js:*:*)
       at *
       at *
@@ -32,7 +33,8 @@ AssertionError [ERR_ASSERTION]: Expected values to be strictly deep-equal:
       at *
       at *,
   expected: { bar: true },
-  operator: 'throws'
+  operator: 'throws',
+  diff: 'simple'
 }
 
 Node.js *
diff --git a/test/parallel/test-assert-class.js b/test/parallel/test-assert-class.js
new file mode 100644
index 00000000000000..62c910051776e2
--- /dev/null
+++ b/test/parallel/test-assert-class.js
@@ -0,0 +1,478 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const { Assert } = require('assert');
+const { inspect } = require('util');
+const { test } = require('node:test');
+
+// Disable colored output to prevent color codes from breaking assertion
+// message comparisons. This should only be an issue when process.stdout
+// is a TTY.
+if (process.stdout.isTTY) {
+  process.env.NODE_DISABLE_COLORS = '1';
+}
+
+test('Assert constructor requires new', () => {
+  assert.throws(() => Assert(), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    name: 'TypeError',
+    message: /Assert/,
+  });
+});
+
+test('Assert class non strict', () => {
+  const assertInstance = new Assert({ diff: undefined, strict: false });
+
+  assertInstance.ok(
+    assert.AssertionError.prototype instanceof Error,
+    'assert.AssertionError instanceof Error'
+  );
+  assertInstance.ok(true);
+  assertInstance.throws(
+    () => {
+      assertInstance.fail();
+    },
+    {
+      code: 'ERR_ASSERTION',
+      name: 'AssertionError',
+      message: 'Failed',
+      operator: 'fail',
+      actual: undefined,
+      expected: undefined,
+      generatedMessage: true,
+      stack: /Failed/,
+    }
+  );
+  assertInstance.equal(undefined, undefined);
+  assertInstance.equal(null, undefined);
+  assertInstance.equal(2, '2');
+  assertInstance.notEqual(true, false);
+  assertInstance.throws(() => assertInstance.deepEqual(/a/), {
+    code: 'ERR_MISSING_ARGS',
+  });
+  assertInstance.throws(() => assertInstance.notDeepEqual('test'), {
+    code: 'ERR_MISSING_ARGS',
+  });
+  assertInstance.notStrictEqual(2, '2');
+  assertInstance.throws(
+    () => assertInstance.strictEqual(2, '2'),
+    assertInstance.AssertionError,
+    "strictEqual(2, '2')"
+  );
+  assertInstance.throws(
+    () => {
+      assertInstance.partialDeepStrictEqual(
+        { a: true },
+        { a: false },
+        'custom message'
+      );
+    },
+    {
+      code: 'ERR_ASSERTION',
+      name: 'AssertionError',
+      message:
+        'custom message\n+ actual - expected\n\n  {\n+   a: true\n-   a: false\n  }\n',
+    }
+  );
+  assertInstance.throws(() => assertInstance.match(/abc/, 'string'), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    message:
+      'The "regexp" argument must be an instance of RegExp. ' +
+      "Received type string ('string')",
+  });
+  assertInstance.throws(() => assertInstance.doesNotMatch(/abc/, 'string'), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    message:
+      'The "regexp" argument must be an instance of RegExp. ' +
+      "Received type string ('string')",
+  });
+
+  /* eslint-disable no-restricted-syntax */
+  {
+    function thrower(errorConstructor) {
+      throw new errorConstructor({});
+    }
+
+    let threw = false;
+    try {
+      assertInstance.doesNotThrow(
+        () => thrower(TypeError),
+        assertInstance.AssertionError
+      );
+    } catch (e) {
+      threw = true;
+      assertInstance.ok(e instanceof TypeError);
+    }
+    assertInstance.ok(
+      threw,
+      'assertInstance.doesNotThrow with an explicit error is eating extra errors'
+    );
+  }
+  {
+    let threw = false;
+    const rangeError = new RangeError('my range');
+
+    try {
+      assertInstance.doesNotThrow(
+        () => {
+          throw new TypeError('wrong type');
+        },
+        TypeError,
+        rangeError
+      );
+    } catch (e) {
+      threw = true;
+      assertInstance.ok(e.message.includes(rangeError.message));
+      assertInstance.ok(e instanceof assertInstance.AssertionError);
+      assertInstance.ok(!e.stack.includes('doesNotThrow'), e);
+    }
+    assertInstance.ok(threw);
+  }
+  /* eslint-enable no-restricted-syntax */
+});
+
+test('Assert class strict', () => {
+  const assertInstance = new Assert();
+
+  assertInstance.equal(assertInstance.equal, assertInstance.strictEqual);
+  assertInstance.equal(
+    assertInstance.deepEqual,
+    assertInstance.deepStrictEqual
+  );
+  assertInstance.equal(assertInstance.notEqual, assertInstance.notStrictEqual);
+  assertInstance.equal(
+    assertInstance.notDeepEqual,
+    assertInstance.notDeepStrictEqual
+  );
+});
+
+test('Assert class with invalid diff option', () => {
+  assert.throws(() => new Assert({ diff: 'invalid' }), {
+    code: 'ERR_INVALID_ARG_VALUE',
+    name: 'TypeError',
+    message: /must be one of "simple", "full"/,
+  });
+});
+
+const longLinesOfAs = 'A\n'.repeat(100);
+const longLinesOFBs = 'B\n'.repeat(100);
+const truncatedAs = 'A\\n'.repeat(10) + '...';
+const truncatedBs = 'B\\n'.repeat(10) + '...';
+
+const longStringOfAs = 'A'.repeat(10_000);
+const longStringOfBs = 'B'.repeat(10_000);
+
+const longLinesOfAsWithEllipsis = longStringOfAs.substring(0, 9_488) + '...';
+const longLinesOFBsWithEllipsis = longStringOfBs.substring(0, 9_488) + '...';
+test('Assert class non strict with full diff', () => {
+  const assertInstance = new Assert({ diff: 'full', strict: false });
+
+  // long strings
+  {
+    assertInstance.throws(
+      () => {
+        assertInstance.strictEqual(longStringOfAs, longStringOfBs);
+      },
+      (err) => {
+        assertInstance.strictEqual(err.code, 'ERR_ASSERTION');
+        assertInstance.strictEqual(err.operator, 'strictEqual');
+        assertInstance.strictEqual(err.diff, 'full');
+        assertInstance.strictEqual(err.actual, longStringOfAs);
+        assertInstance.strictEqual(err.expected, longStringOfBs);
+
+        assertInstance.strictEqual(
+          err.message,
+          `Expected values to be strictly equal:\n+ actual - expected\n\n` +
+            `+ '${longStringOfAs}'\n- '${longStringOfBs}'\n`
+        );
+        assertInstance.ok(
+          inspect(err).includes(`actual: '${longLinesOfAsWithEllipsis}'`)
+        );
+        assertInstance.ok(
+          inspect(err).includes(`expected: '${longLinesOFBsWithEllipsis}'`)
+        );
+        return true;
+      }
+    );
+
+    assertInstance.throws(
+      () => {
+        assertInstance.notStrictEqual(longStringOfAs, longStringOfAs);
+      },
+      (err) => {
+        assertInstance.strictEqual(err.code, 'ERR_ASSERTION');
+        assertInstance.strictEqual(err.operator, 'notStrictEqual');
+        assertInstance.strictEqual(err.diff, 'full');
+        assertInstance.strictEqual(err.actual, longStringOfAs);
+        assertInstance.strictEqual(err.expected, longStringOfAs);
+
+        assertInstance.strictEqual(
+          err.message,
+          `Expected "actual" to be strictly unequal to:\n\n` +
+            `'${longStringOfAs}'`
+        );
+        assertInstance.ok(
+          inspect(err).includes(`actual: '${longLinesOfAsWithEllipsis}'`)
+        );
+        assertInstance.ok(
+          inspect(err).includes(`expected: '${longLinesOfAsWithEllipsis}'`)
+        );
+        return true;
+      }
+    );
+
+    assertInstance.throws(
+      () => {
+        assertInstance.deepEqual(longStringOfAs, longStringOfBs);
+      },
+      (err) => {
+        assertInstance.strictEqual(err.code, 'ERR_ASSERTION');
+        assertInstance.strictEqual(err.operator, 'deepEqual');
+        assertInstance.strictEqual(err.diff, 'full');
+        assertInstance.strictEqual(err.actual, longStringOfAs);
+        assertInstance.strictEqual(err.expected, longStringOfBs);
+
+        assertInstance.strictEqual(
+          err.message,
+          `Expected values to be loosely deep-equal:\n\n` +
+            `'${longStringOfAs}'\n\nshould loosely deep-equal\n\n'${longStringOfBs}'`
+        );
+        assertInstance.ok(
+          inspect(err).includes(`actual: '${longLinesOfAsWithEllipsis}'`)
+        );
+        assertInstance.ok(
+          inspect(err).includes(`expected: '${longLinesOFBsWithEllipsis}'`)
+        );
+        return true;
+      }
+    );
+  }
+
+  // long lines
+  {
+    assertInstance.throws(
+      () => {
+        assertInstance.strictEqual(longLinesOfAs, longLinesOFBs);
+      },
+      (err) => {
+        assertInstance.strictEqual(err.code, 'ERR_ASSERTION');
+        assertInstance.strictEqual(err.operator, 'strictEqual');
+        assertInstance.strictEqual(err.diff, 'full');
+        assertInstance.strictEqual(err.actual, longLinesOfAs);
+        assertInstance.strictEqual(err.expected, longLinesOFBs);
+
+        assertInstance.strictEqual(err.message.split('\n').length, 204);
+        assertInstance.strictEqual(err.actual.split('\n').length, 101);
+        assertInstance.ok(
+          err.message.includes('Expected values to be strictly equal')
+        );
+        assertInstance.ok(inspect(err).includes(`actual: '${truncatedAs}`));
+        assertInstance.ok(inspect(err).includes(`expected: '${truncatedBs}`));
+        return true;
+      }
+    );
+
+    assertInstance.throws(
+      () => {
+        assertInstance.notStrictEqual(longLinesOfAs, longLinesOfAs);
+      },
+      (err) => {
+        assertInstance.strictEqual(err.code, 'ERR_ASSERTION');
+        assertInstance.strictEqual(err.operator, 'notStrictEqual');
+        assertInstance.strictEqual(err.diff, 'full');
+        assertInstance.strictEqual(err.actual, longLinesOfAs);
+        assertInstance.strictEqual(err.expected, longLinesOfAs);
+
+        assertInstance.strictEqual(err.message.split('\n').length, 103);
+        assertInstance.strictEqual(err.actual.split('\n').length, 101);
+        assertInstance.ok(
+          err.message.includes(`Expected "actual" to be strictly unequal to:`)
+        );
+        assertInstance.ok(inspect(err).includes(`actual: '${truncatedAs}`));
+        assertInstance.ok(inspect(err).includes(`expected: '${truncatedAs}`));
+        return true;
+      }
+    );
+
+    assertInstance.throws(
+      () => {
+        assertInstance.deepEqual(longLinesOfAs, longLinesOFBs);
+      },
+      (err) => {
+        assertInstance.strictEqual(err.code, 'ERR_ASSERTION');
+        assertInstance.strictEqual(err.operator, 'deepEqual');
+        assertInstance.strictEqual(err.diff, 'full');
+        assertInstance.strictEqual(err.actual, longLinesOfAs);
+        assertInstance.strictEqual(err.expected, longLinesOFBs);
+
+        assertInstance.strictEqual(err.message.split('\n').length, 205);
+        assertInstance.strictEqual(err.actual.split('\n').length, 101);
+        assertInstance.ok(
+          err.message.includes(`Expected values to be loosely deep-equal:`)
+        );
+        assertInstance.ok(inspect(err).includes(`actual: '${truncatedAs}`));
+        assertInstance.ok(inspect(err).includes(`expected: '${truncatedBs}`));
+        return true;
+      }
+    );
+  }
+});
+
+test('Assert class non strict with simple diff', () => {
+  const assertInstance = new Assert({ diff: 'simple', strict: false });
+
+  // long strings
+  {
+    assertInstance.throws(
+      () => {
+        assertInstance.strictEqual(longStringOfAs, longStringOfBs);
+      },
+      (err) => {
+        assertInstance.strictEqual(err.code, 'ERR_ASSERTION');
+        assertInstance.strictEqual(err.operator, 'strictEqual');
+        assertInstance.strictEqual(err.diff, 'simple');
+        assertInstance.strictEqual(err.actual, longStringOfAs);
+        assertInstance.strictEqual(err.expected, longStringOfBs);
+
+        assertInstance.strictEqual(
+          err.message,
+          `Expected values to be strictly equal:\n+ actual - expected\n\n` +
+            `+ '${longStringOfAs}'\n- '${longStringOfBs}'\n`
+        );
+        assertInstance.ok(
+          inspect(err).includes(`actual: '${longLinesOfAsWithEllipsis}'`)
+        );
+        assertInstance.ok(
+          inspect(err).includes(`expected: '${longLinesOFBsWithEllipsis}'`)
+        );
+        return true;
+      }
+    );
+
+    assertInstance.throws(
+      () => {
+        assertInstance.notStrictEqual(longStringOfAs, longStringOfAs);
+      },
+      (err) => {
+        assertInstance.strictEqual(err.code, 'ERR_ASSERTION');
+        assertInstance.strictEqual(err.operator, 'notStrictEqual');
+        assertInstance.strictEqual(err.diff, 'simple');
+        assertInstance.strictEqual(err.actual, longStringOfAs);
+        assertInstance.strictEqual(err.expected, longStringOfAs);
+
+        assertInstance.strictEqual(
+          err.message,
+          `Expected "actual" to be strictly unequal to:\n\n` +
+            `'${longStringOfAs}'`
+        );
+        assertInstance.ok(
+          inspect(err).includes(`actual: '${longLinesOfAsWithEllipsis}'`)
+        );
+        assertInstance.ok(
+          inspect(err).includes(`expected: '${longLinesOfAsWithEllipsis}'`)
+        );
+        return true;
+      }
+    );
+
+    assertInstance.throws(
+      () => {
+        assertInstance.deepEqual(longStringOfAs, longStringOfBs);
+      },
+      (err) => {
+        assertInstance.strictEqual(err.code, 'ERR_ASSERTION');
+        assertInstance.strictEqual(err.operator, 'deepEqual');
+        assertInstance.strictEqual(err.diff, 'simple');
+        assertInstance.strictEqual(err.actual, longStringOfAs);
+        assertInstance.strictEqual(err.expected, longStringOfBs);
+
+        assertInstance.strictEqual(
+          err.message,
+          `Expected values to be loosely deep-equal:\n\n` +
+            `'${
+              longStringOfAs.substring(0, 508) + '...'
+            }\n\nshould loosely deep-equal\n\n'${
+              longStringOfBs.substring(0, 508) + '...'
+            }`
+        );
+        assertInstance.ok(
+          inspect(err).includes(`actual: '${longLinesOfAsWithEllipsis}'`)
+        );
+        assertInstance.ok(
+          inspect(err).includes(`expected: '${longLinesOFBsWithEllipsis}'`)
+        );
+        return true;
+      }
+    );
+  }
+
+  // long lines
+  {
+    assertInstance.throws(
+      () => {
+        assertInstance.strictEqual(longLinesOfAs, longLinesOFBs);
+      },
+      (err) => {
+        assertInstance.strictEqual(err.code, 'ERR_ASSERTION');
+        assertInstance.strictEqual(err.operator, 'strictEqual');
+        assertInstance.strictEqual(err.diff, 'simple');
+        assertInstance.strictEqual(err.actual, longLinesOfAs);
+        assertInstance.strictEqual(err.expected, longLinesOFBs);
+        assertInstance.strictEqual(err.message.split('\n').length, 204);
+        assertInstance.strictEqual(err.actual.split('\n').length, 101);
+
+        assertInstance.ok(
+          err.message.includes('Expected values to be strictly equal')
+        );
+        assertInstance.ok(inspect(err).includes(`actual: '${truncatedAs}`));
+        assertInstance.ok(inspect(err).includes(`expected: '${truncatedBs}`));
+        return true;
+      }
+    );
+
+    assertInstance.throws(
+      () => {
+        assertInstance.notStrictEqual(longLinesOfAs, longLinesOfAs);
+      },
+      (err) => {
+        assertInstance.strictEqual(err.code, 'ERR_ASSERTION');
+        assertInstance.strictEqual(err.operator, 'notStrictEqual');
+        assertInstance.strictEqual(err.diff, 'simple');
+        assertInstance.strictEqual(err.actual, longLinesOfAs);
+        assertInstance.strictEqual(err.expected, longLinesOfAs);
+
+        assertInstance.strictEqual(err.message.split('\n').length, 50);
+        assertInstance.strictEqual(err.actual.split('\n').length, 101);
+        assertInstance.ok(
+          err.message.includes(`Expected "actual" to be strictly unequal to:`)
+        );
+        assertInstance.ok(inspect(err).includes(`actual: '${truncatedAs}`));
+        assertInstance.ok(inspect(err).includes(`expected: '${truncatedAs}`));
+        return true;
+      }
+    );
+
+    assertInstance.throws(
+      () => {
+        assertInstance.deepEqual(longLinesOfAs, longLinesOFBs);
+      },
+      (err) => {
+        assertInstance.strictEqual(err.code, 'ERR_ASSERTION');
+        assertInstance.strictEqual(err.operator, 'deepEqual');
+        assertInstance.strictEqual(err.diff, 'simple');
+        assertInstance.strictEqual(err.actual, longLinesOfAs);
+        assertInstance.strictEqual(err.expected, longLinesOFBs);
+
+        assertInstance.strictEqual(err.message.split('\n').length, 109);
+        assertInstance.strictEqual(err.actual.split('\n').length, 101);
+        assertInstance.ok(
+          err.message.includes(`Expected values to be loosely deep-equal:`)
+        );
+        assertInstance.ok(inspect(err).includes(`actual: '${truncatedAs}`));
+        assertInstance.ok(inspect(err).includes(`expected: '${truncatedBs}`));
+        return true;
+      }
+    );
+  }
+});
diff --git a/test/parallel/test-fs-promises.js b/test/parallel/test-fs-promises.js
index 796ad3224c4dba..d2f523742798e4 100644
--- a/test/parallel/test-fs-promises.js
+++ b/test/parallel/test-fs-promises.js
@@ -58,7 +58,7 @@ assert.strictEqual(
       code: 'ENOENT',
       name: 'Error',
       message: /^ENOENT: no such file or directory, access/,
-      stack: /at async ok\.rejects/
+      stack: /at async Assert\.rejects/
     }
   ).then(common.mustCall());
 
diff --git a/test/parallel/test-runner-assert.js b/test/parallel/test-runner-assert.js
index 2c495baca0afd2..236f1851d6d262 100644
--- a/test/parallel/test-runner-assert.js
+++ b/test/parallel/test-runner-assert.js
@@ -7,6 +7,8 @@ test('expected methods are on t.assert', (t) => {
   const uncopiedKeys = [
     'AssertionError',
     'strict',
+    'Assert',
+    'options',
   ];
   const assertKeys = Object.keys(assert).filter((key) => !uncopiedKeys.includes(key));
   const expectedKeys = ['snapshot', 'fileSnapshot'].concat(assertKeys).sort();