diff --git a/doc/api/errors.md b/doc/api/errors.md
index 40b8e7ab74cf71..e0c7414564694f 100644
--- a/doc/api/errors.md
+++ b/doc/api/errors.md
@@ -570,6 +570,12 @@ The `'ERR_ARG_NOT_ITERABLE'` error code is used generically to identify that an
 iterable argument (i.e. a value that works with `for...of` loops) is required,
 but not provided to a Node.js API.
 
+<a id="ERR_FALSY_VALUE_REJECTION"></a>
+### ERR_FALSY_VALUE_REJECTION
+
+The `ERR_FALSY_VALUE_REJECTION` error code is used by the `util.callbackify()`
+API when a callbackified `Promise` is rejected with a falsy value (e.g. `null`).
+
 <a id="ERR_INVALID_ARG_TYPE"></a>
 ### ERR_INVALID_ARG_TYPE
 
diff --git a/doc/api/util.md b/doc/api/util.md
index 839bdadf76e1ec..9fce6294e18b17 100644
--- a/doc/api/util.md
+++ b/doc/api/util.md
@@ -10,6 +10,64 @@ module developers as well. It can be accessed using:
 const util = require('util');
 ```
 
+## util.callbackify(original)
+<!-- YAML
+added: REPLACEME
+-->
+
+* `original` {Function} An `async` function
+* Returns: {Function} a callback style function
+
+Takes an `async` function (or a function that returns a Promise) and returns a
+function following the Node.js error first callback style. In the callback, the
+first argument will be the rejection reason (or `null` if the Promise resolved),
+and the second argument will be the resolved value.
+
+For example:
+
+```js
+const util = require('util');
+
+async function fn() {
+  return await Promise.resolve('hello world');
+}
+const callbackFunction = util.callbackify(fn);
+
+callbackFunction((err, ret) => {
+  if (err) throw err;
+  console.log(ret);
+});
+```
+
+Will print:
+
+```txt
+hello world
+```
+
+*Note*:
+
+* The callback is executed asynchronously, and will have a limited stack trace.
+If the callback throws, the process will emit an [`'uncaughtException'`][]
+event, and if not handled will exit.
+
+* Since `null` has a special meaning as the first argument to a callback, if a
+wrapped function rejects a `Promise` with a falsy value as a reason, the value
+is wrapped in an `Error` with the original value stored in a field named
+`reason`.
+  ```js
+  function fn() {
+    return Promise.reject(null);
+  }
+  const callbackFunction = util.callbackify(fn);
+
+  callbackFunction((err, ret) => {
+    // When the Promise was rejected with `null` it is wrapped with an Error and
+    // the original value is stored in `reason`.
+    err && err.hasOwnProperty('reason') && err.reason === null;  // true
+  });
+  ```
+
 ## util.debuglog(section)
 <!-- YAML
 added: v0.11.3
@@ -955,6 +1013,7 @@ Deprecated predecessor of `console.log`.
 [`Object.assign()`]: https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Object/assign
 [`console.error()`]: console.html#console_console_error_data_args
 [`console.log()`]: console.html#console_console_log_data_args
+[`'uncaughtException'`]: process.html#process_event_uncaughtexception
 [`util.inspect()`]: #util_util_inspect_object_options
 [`util.promisify()`]: #util_util_promisify_original
 [Custom inspection functions on Objects]: #util_custom_inspection_functions_on_objects
diff --git a/lib/internal/errors.js b/lib/internal/errors.js
index 153cf45bbbba07..ac286a6040ba9a 100644
--- a/lib/internal/errors.js
+++ b/lib/internal/errors.js
@@ -112,6 +112,7 @@ module.exports = exports = {
 // Note: Please try to keep these in alphabetical order
 E('ERR_ARG_NOT_ITERABLE', '%s must be iterable');
 E('ERR_ASSERTION', (msg) => msg);
+E('ERR_FALSY_VALUE_REJECTION', 'Promise was rejected with falsy value');
 E('ERR_INVALID_ARG_TYPE', invalidArgType);
 E('ERR_INVALID_CALLBACK', 'callback must be a function');
 E('ERR_INVALID_FD', (fd) => `"fd" must be a positive integer: ${fd}`);
diff --git a/lib/util.js b/lib/util.js
index 81e3a42f053a6d..8d3708a7c6f021 100644
--- a/lib/util.js
+++ b/lib/util.js
@@ -25,6 +25,7 @@ const uv = process.binding('uv');
 const Buffer = require('buffer').Buffer;
 const internalUtil = require('internal/util');
 const binding = process.binding('util');
+const errors = require('internal/errors');
 
 const isError = internalUtil.isError;
 
@@ -1055,3 +1056,53 @@ process.versions[exports.inspect.custom] =
   (depth) => exports.format(JSON.parse(JSON.stringify(process.versions)));
 
 exports.promisify = internalUtil.promisify;
+
+function callbackifyOnRejected(reason, cb) {
+  // `!reason` guard inspired by bluebird (Ref: https://goo.gl/t5IS6M).
+  // Because `null` is a special error value in callbacks which means "no error
+  // occurred", we error-wrap so the callback consumer can distinguish between
+  // "the promise rejected with null" or "the promise fulfilled with undefined".
+  if (!reason) {
+    const newReason = new errors.Error('ERR_FALSY_VALUE_REJECTION');
+    newReason.reason = reason;
+    reason = newReason;
+    Error.captureStackTrace(reason, callbackifyOnRejected);
+  }
+  return cb(reason);
+}
+
+
+function callbackify(original) {
+  if (typeof original !== 'function') {
+    throw new errors.TypeError(
+      'ERR_INVALID_ARG_TYPE',
+      'original',
+      'function');
+  }
+
+  // We DO NOT return the promise as it gives the user a false sense that
+  // the promise is actually somehow related to the callback's execution
+  // and that the callback throwing will reject the promise.
+  function callbackified(...args) {
+    const maybeCb = args.pop();
+    if (typeof maybeCb !== 'function') {
+      throw new errors.TypeError(
+        'ERR_INVALID_ARG_TYPE',
+        'last argument',
+        'function');
+    }
+    const cb = (...args) => { Reflect.apply(maybeCb, this, args); };
+    // In true node style we process the callback on `nextTick` with all the
+    // implications (stack, `uncaughtException`, `async_hooks`)
+    Reflect.apply(original, this, args)
+      .then((ret) => process.nextTick(cb, null, ret),
+            (rej) => process.nextTick(callbackifyOnRejected, rej, cb));
+  }
+
+  Object.setPrototypeOf(callbackified, Object.getPrototypeOf(original));
+  Object.defineProperties(callbackified,
+                          Object.getOwnPropertyDescriptors(original));
+  return callbackified;
+}
+
+exports.callbackify = callbackify;
diff --git a/test/fixtures/uncaught-exceptions/callbackify1.js b/test/fixtures/uncaught-exceptions/callbackify1.js
new file mode 100644
index 00000000000000..1fbe7c8ebfd7c5
--- /dev/null
+++ b/test/fixtures/uncaught-exceptions/callbackify1.js
@@ -0,0 +1,15 @@
+'use strict';
+
+// Used to test that `uncaughtException` is emitted
+
+const { callbackify } = require('util');
+
+{
+  async function fn() { }
+
+  const cbFn = callbackify(fn);
+
+  cbFn((err, ret) => {
+    throw new Error(__filename);
+  });
+}
diff --git a/test/fixtures/uncaught-exceptions/callbackify2.js b/test/fixtures/uncaught-exceptions/callbackify2.js
new file mode 100644
index 00000000000000..9080da234f3c04
--- /dev/null
+++ b/test/fixtures/uncaught-exceptions/callbackify2.js
@@ -0,0 +1,22 @@
+'use strict';
+
+// Used to test the `uncaughtException` err object
+
+const assert = require('assert');
+const { callbackify } = require('util');
+
+{
+  const sentinel = new Error(__filename);
+  process.once('uncaughtException', (err) => {
+    assert.strictEqual(err, sentinel);
+    // Calling test will use `stdout` to assert value of `err.message`
+    console.log(err.message);
+  });
+
+  async function fn() {
+    return await Promise.reject(sentinel);
+  }
+
+  const cbFn = callbackify(fn);
+  cbFn((err, ret) => assert.ifError(err));
+}
diff --git a/test/parallel/test-util-callbackify.js b/test/parallel/test-util-callbackify.js
new file mode 100644
index 00000000000000..a385538159c8a8
--- /dev/null
+++ b/test/parallel/test-util-callbackify.js
@@ -0,0 +1,261 @@
+'use strict';
+const common = require('../common');
+
+// This test checks that the semantics of `util.callbackify` are as described in
+// the API docs
+
+const assert = require('assert');
+const { callbackify } = require('util');
+const { join } = require('path');
+const { execFile } = require('child_process');
+const fixtureDir = join(common.fixturesDir, 'uncaught-exceptions');
+const values = [
+  'hello world',
+  null,
+  undefined,
+  false,
+  0,
+  {},
+  { key: 'value' },
+  Symbol('I am a symbol'),
+  function ok() {},
+  ['array', 'with', 4, 'values'],
+  new Error('boo')
+];
+
+{
+  // Test that the resolution value is passed as second argument to callback
+  for (const value of values) {
+    // Test and `async function`
+    async function asyncFn() {
+      return await Promise.resolve(value);
+    }
+
+    const cbAsyncFn = callbackify(asyncFn);
+    cbAsyncFn(common.mustCall((err, ret) => {
+      assert.ifError(err);
+      assert.strictEqual(ret, value);
+    }));
+
+    // Test Promise factory
+    function promiseFn() {
+      return Promise.resolve(value);
+    }
+
+    const cbPromiseFn = callbackify(promiseFn);
+    cbPromiseFn(common.mustCall((err, ret) => {
+      assert.ifError(err);
+      assert.strictEqual(ret, value);
+    }));
+
+    // Test Thenable
+    function thenableFn() {
+      return {
+        then(onRes, onRej) {
+          onRes(value);
+        }
+      };
+    }
+
+    const cbThenableFn = callbackify(thenableFn);
+    cbThenableFn(common.mustCall((err, ret) => {
+      assert.ifError(err);
+      assert.strictEqual(ret, value);
+    }));
+  }
+}
+
+{
+  // Test that rejection reason is passed as first argument to callback
+  for (const value of values) {
+    // Test an `async function`
+    async function asyncFn() {
+      return await Promise.reject(value);
+    }
+
+    const cbAsyncFn = callbackify(asyncFn);
+    cbAsyncFn(common.mustCall((err, ret) => {
+      assert.strictEqual(ret, undefined);
+      if (err instanceof Error) {
+        if ('reason' in err) {
+          assert(!value);
+          assert.strictEqual(err.code, 'ERR_FALSY_VALUE_REJECTION');
+          assert.strictEqual(err.reason, value);
+        } else {
+          assert.strictEqual(String(value).endsWith(err.message), true);
+        }
+      } else {
+        assert.strictEqual(err, value);
+      }
+    }));
+
+    // test a Promise factory
+    function promiseFn() {
+      return Promise.reject(value);
+    }
+
+    const cbPromiseFn = callbackify(promiseFn);
+    cbPromiseFn(common.mustCall((err, ret) => {
+      assert.strictEqual(ret, undefined);
+      if (err instanceof Error) {
+        if ('reason' in err) {
+          assert(!value);
+          assert.strictEqual(err.code, 'ERR_FALSY_VALUE_REJECTION');
+          assert.strictEqual(err.reason, value);
+        } else {
+          assert.strictEqual(String(value).endsWith(err.message), true);
+        }
+      } else {
+        assert.strictEqual(err, value);
+      }
+    }));
+
+    // Test Thenable
+    function thenableFn() {
+      return {
+        then(onRes, onRej) {
+          onRej(value);
+        }
+      };
+    }
+
+    const cbThenableFn = callbackify(thenableFn);
+    cbThenableFn(common.mustCall((err, ret) => {
+      assert.strictEqual(ret, undefined);
+      if (err instanceof Error) {
+        if ('reason' in err) {
+          assert(!value);
+          assert.strictEqual(err.code, 'ERR_FALSY_VALUE_REJECTION');
+          assert.strictEqual(err.reason, value);
+        } else {
+          assert.strictEqual(String(value).endsWith(err.message), true);
+        }
+      } else {
+        assert.strictEqual(err, value);
+      }
+    }));
+  }
+}
+
+{
+  // Test that arguments passed to callbackified function are passed to original
+  for (const value of values) {
+    async function asyncFn(arg) {
+      assert.strictEqual(arg, value);
+      return await Promise.resolve(arg);
+    }
+
+    const cbAsyncFn = callbackify(asyncFn);
+    cbAsyncFn(value, common.mustCall((err, ret) => {
+      assert.ifError(err);
+      assert.strictEqual(ret, value);
+    }));
+
+    function promiseFn(arg) {
+      assert.strictEqual(arg, value);
+      return Promise.resolve(arg);
+    }
+
+    const cbPromiseFn = callbackify(promiseFn);
+    cbPromiseFn(value, common.mustCall((err, ret) => {
+      assert.ifError(err);
+      assert.strictEqual(ret, value);
+    }));
+  }
+}
+
+{
+  // Test that `this` binding is the same for callbackified and original
+  for (const value of values) {
+    const iAmThis = {
+      fn(arg) {
+        assert.strictEqual(this, iAmThis);
+        return Promise.resolve(arg);
+      },
+    };
+    iAmThis.cbFn = callbackify(iAmThis.fn);
+    iAmThis.cbFn(value, common.mustCall(function(err, ret) {
+      assert.ifError(err);
+      assert.strictEqual(ret, value);
+      assert.strictEqual(this, iAmThis);
+    }));
+
+    const iAmThat = {
+      async fn(arg) {
+        assert.strictEqual(this, iAmThat);
+        return await Promise.resolve(arg);
+      },
+    };
+    iAmThat.cbFn = callbackify(iAmThat.fn);
+    iAmThat.cbFn(value, common.mustCall(function(err, ret) {
+      assert.ifError(err);
+      assert.strictEqual(ret, value);
+      assert.strictEqual(this, iAmThat);
+    }));
+  }
+}
+
+{
+  // Test that callback that throws emits an `uncaughtException` event
+  const fixture = join(fixtureDir, 'callbackify1.js');
+  execFile(
+    process.execPath,
+    [fixture],
+    common.mustCall((err, stdout, stderr) => {
+      assert.strictEqual(err.code, 1);
+      assert.strictEqual(Object.getPrototypeOf(err).name, 'Error');
+      assert.strictEqual(stdout, '');
+      const errLines = stderr.trim().split(/[\r\n]+/g);
+      const errLine = errLines.find((l) => /^Error/.exec(l));
+      assert.strictEqual(errLine, `Error: ${fixture}`);
+    })
+  );
+}
+
+{
+  // Test that handled `uncaughtException` works and passes rejection reason
+  const fixture = join(fixtureDir, 'callbackify2.js');
+  execFile(
+    process.execPath,
+    [fixture],
+    common.mustCall((err, stdout, stderr) => {
+      assert.ifError(err);
+      assert.strictEqual(stdout.trim(), fixture);
+      assert.strictEqual(stderr, '');
+    })
+  );
+}
+
+{
+  // Verify that non-function inputs throw.
+  ['foo', null, undefined, false, 0, {}, Symbol(), []].forEach((value) => {
+    assert.throws(() => {
+      callbackify(value);
+    }, common.expectsError({
+      code: 'ERR_INVALID_ARG_TYPE',
+      type: TypeError,
+      message: 'The "original" argument must be of type function'
+    }));
+  });
+}
+
+{
+  async function asyncFn() {
+    return await Promise.resolve(42);
+  }
+
+  const cb = callbackify(asyncFn);
+  const args = [];
+
+  // Verify that the last argument to the callbackified function is a function.
+  ['foo', null, undefined, false, 0, {}, Symbol(), []].forEach((value) => {
+    args.push(value);
+    assert.throws(() => {
+      cb(...args);
+    }, common.expectsError({
+      code: 'ERR_INVALID_ARG_TYPE',
+      type: TypeError,
+      message: 'The "last argument" argument must be of type function'
+    }));
+  });
+}