diff --git a/_blogposts/2023-02-02-release-10-1.mdx b/_blogposts/2023-02-02-release-10-1.mdx
new file mode 100644
index 000000000..9c2eeb077
--- /dev/null
+++ b/_blogposts/2023-02-02-release-10-1.mdx
@@ -0,0 +1,308 @@
+---
+author: rescript-team
+date: "2023-02-02"
+title: ReScript 10.1
+badge: release
+description: |
+  Async/await & better Promise support, JSX v4, and more!
+---
+
+## Introduction
+
+We are happy to announce ReScript 10.1!
+
+ReScript is a robustly typed language that compiles to efficient and human-readable JavaScript. It comes with one of the fastest build toolchains and offers first class support for interoperating with ReactJS and other existing JavaScript code.
+
+Use `npm` to install the newest [10.1 release](https://www.npmjs.com/package/rescript/v/10.1.2):
+
+```
+npm install rescript
+
+# or
+
+npm install rescript@10.1
+```
+
+This version comes with two major language improvements we've all been waiting for. **async/await support** for an easy way to write asynchronous code in a synchronous manner, and a **new JSX transform** with better ergonomics, code generation and React 18 support.
+
+Alongside the major changes, there have been many bugfixes and other improvements that won't be covered in this post.
+
+Feel free to check the [Changelog](https://github.com/rescript-lang/rescript-compiler/blob/master/CHANGELOG.md#1011) for all the details.
+
+## New `async` / `await` syntax
+
+Async / await has arrived. Similar to its JS counterparts, you are now able to define `async` functions and use the `await` operator to unwrap a promise value. This allows writing asynchronous code in a synchronous fashion.
+
+**Example:**
+
+```res
+// Some fictive functionality that offers asynchronous network actions
+@val external fetchUserMail: string => promise<string> = "GlobalAPI.fetchUserMail"
+@val external sendAnalytics: string => promise<unit> = "GlobalAPI.sendAnalytics"
+
+// We use the `async` keyword to allow the use of `await` in the function body
+let logUserDetails = async (userId: string) => {
+  // We use `await` to fetch the user email from our fictive user endpoint
+  let email = await fetchUserMail(userId)
+
+  await sendAnalytics(`User details have been logged for ${userId}`)
+
+  Js.log(`Email address for user ${userId}: ${email}`)
+}
+```
+
+To learn more about our async / await feature, check out the relevant [manual section](/docs/manual/latest/async-await).
+
+## New `promise` builtin type and `Js.Promise2` module
+
+In previous versions of ReScript, promises were expressed as a `Js.Promise.t<'a>` type, which was a little tedious to type. From now on, users may use the `promise<'a>` type instead.
+
+Quick example of a `.resi` file using the new `promise` type:
+
+```resi
+// User.resi
+type user
+
+let fetchUser: string => promise<user>
+```
+
+Way easier on the eyes, don't you think? Note that the new `promise` type is fully compatible with `Js.Promise.t` (no breaking changes).
+
+Additionally, we also introduced the `Js.Promise2` module as a stepping stone to migrate `Js.Promise` based code to a first-pipe (->) friendly solution. For the daily practise you'll almost always want to use `async` / `await` to handle promises.
+
+(*Sidenote*: We are also well aware that our users want a solution to unify `Belt`, `Js` and `Js.xxx2` and have a fully featured "standard library" instead of adding more `Js.xxx2` modules. Good news is that we have a solution in the pipeline to fix this. `Js.Promise2` was introduced to ease the process later on and is not supposed to be the panacea of promise handling.)
+
+If you are already using a third-party promise library like [ryyppy/rescript-promise](https://github.com/ryyppy/rescript-promise) or similar, there's no need to migrate any existing code. Introduce `async` / `await` gradually in your codebase as you go.
+
+
+## New JSX v4 syntax
+
+ReScript 10.1 now ships with JSX v4. Here's what's new:
+
+- **Cleaner interop.** Due to recent improvements in the type checker, the `@react.component` transformation doesn't require any `makeProps` convention anymore. `make` functions will now be transformed into a `prop` type and a component function. That's it.
+- **Two new transformation modes**. JSX v4 comes with a `classic` mode (= `React.createElement`) and `automatic` mode (= `jsx-runtime` calls). The latter is the new default, moving forward with `rescript/react@0.11` and `React@18`.
+- **Allow mixing JSX configurations on the project and module level.** Gradually mix and match JSX transformations and modes without migrating any old code!
+- **Pass `prop` types** to `@react.component`. You can now fine tune `@react.component` with your specific prop type needs. Very useful for libraries and frameworks to define component interfaces.
+- **Less boilerplate when using `React.Context`**. Check out our [example](/docs/react/latest/migrate-react#reactcontext) for comparison. 
+- **Revisited props spread operator.** This will allow users to spread records in JSX without sacrificing their sanity. Note that this implementation has harder constraints than its JS counterpart. (requires `rescript/react@0.11` or higher)
+- **Better type inference of props.** Type inference when passing e.g. variants that are defined in the same module as the component is much improved. With the earlier JSX version, you'd often need to write code like this in order for the compiler to understand which variant you're passing: `<Button variant=Button.Primary text="Click" />`. With JSX v4, you won't need to tell the compiler where the variant you're passing is located: `<Button variant=Primary text="Click" />`.
+
+Code tells more than words, so here's a non-exhaustive code example to highlight the different JSX features. Make sure to also check out the JS output and play around with the code in our newest playground!
+
+<CodeTab labels={["ReScript", "JS Output"]}>
+
+```res
+// Set the jsx configuration per module
+@@jsxConfig({version: 4, mode: "automatic"})
+
+module AutomaticModeExample = {
+  // "automatic" mode will compile jsx to the React 18 compatible
+  // jsx-runtime calls
+  @@jsxConfig({version: 4, mode: "automatic"})
+
+  @react.component
+  let make = (~name) => {
+    <div> {React.string(`Hello ${name}`)} </div>
+  }
+}
+
+module ClassicModeExample = {
+  // "classic" mode will compile jsx to React.createElement calls
+  @@jsxConfig({version: 4, mode: "classic"})
+
+  @react.component
+  let make = (~name) => {
+    <div> {React.string(`Hello ${name}`)} </div>
+  }
+}
+
+module NoAttributeExample = {
+  // No need for `makeProps` anymore
+  type props = {name: string}
+
+  let make = (props: props) => {
+    <div> {React.string(`Hello ${props.name}`)} </div>
+  }
+}
+
+module ReactInterfaceExample: {
+  @react.component
+  let make: (~name: string, ~age: int=?) => React.element
+} = {
+  @react.component
+  let make = (~name, ~age=0) => {
+    <div>
+      {React.string(
+        `Hello ${name}, you are ${Belt.Int.toString(age)} years old.`,
+      )}
+    </div>
+  }
+}
+
+module PropTypeInjectionExample = {
+  // Let's assume we have a prop type that we wanna enforce
+  // as our labeled arguments
+  type someoneElsesProps = {isHuman: bool}
+
+  // Here we tell the `react.component` decorator what props to infer.
+  // Useful for e.g. NextJS usage, or to create components that should
+  // comply to certain library component interfaces
+  @react.component(: someoneElsesProps)
+  let make = (~isHuman) => {
+    let msg = switch isHuman {
+    | true => "hello human"
+    | false => "hello fellow computer"
+    }
+    <div> {React.string(msg)} </div>
+  }
+}
+
+module PropSpreadExample = {
+  // Note: This will require @rescript/react 0.11 or later
+  @@jsxConfig({version: 4, mode: "automatic"})
+
+  @react.component
+  let make = () => {
+    let props = {NoAttributeExample.name: "World"}
+
+    <NoAttributeExample {...props} />
+  }
+}
+
+let root =
+  <div>
+    <AutomaticModeExample name="Automatic" />
+    <ClassicModeExample name="Classic" />
+    <NoAttributeExample name="NoAttribute" />
+    <ReactInterfaceExample name="Interface" />
+    <PropTypeInjectionExample isHuman=true />
+    <PropSpreadExample />
+  </div>
+```
+
+```js
+import * as React from "react";
+import * as JsxRuntime from "react/jsx-runtime";
+
+function Playground$AutomaticModeExample(props) {
+  return JsxRuntime.jsx("div", {
+              children: "Hello " + props.name + ""
+            });
+}
+
+var AutomaticModeExample = {
+  make: Playground$AutomaticModeExample
+};
+
+function Playground$ClassicModeExample(props) {
+  return React.createElement("div", undefined, "Hello " + props.name + "");
+}
+
+var ClassicModeExample = {
+  make: Playground$ClassicModeExample
+};
+
+function make(props) {
+  return JsxRuntime.jsx("div", {
+              children: "Hello " + props.name + ""
+            });
+}
+
+var NoAttributeExample = {
+  make: make
+};
+
+function Playground$ReactInterfaceExample(props) {
+  var age = props.age;
+  var age$1 = age !== undefined ? age : 0;
+  return JsxRuntime.jsx("div", {
+              children: "Hello " + props.name + ", you are " + String(age$1) + " years old."
+            });
+}
+
+var ReactInterfaceExample = {
+  make: Playground$ReactInterfaceExample
+};
+
+function Playground$PropTypeInjectionExample(props) {
+  var msg = props.isHuman ? "hello human" : "hello fellow computer";
+  return JsxRuntime.jsx("div", {
+              children: msg
+            });
+}
+
+var PropTypeInjectionExample = {
+  make: Playground$PropTypeInjectionExample
+};
+
+function Playground$PropSpreadExample(props) {
+  return JsxRuntime.jsx(make, {
+              name: "World"
+            });
+}
+
+var PropSpreadExample = {
+  make: Playground$PropSpreadExample
+};
+
+var root = JsxRuntime.jsxs("div", {
+      children: [
+        JsxRuntime.jsx(Playground$AutomaticModeExample, {
+              name: "Automatic"
+            }),
+        JsxRuntime.jsx(Playground$ClassicModeExample, {
+              name: "Classic"
+            }),
+        JsxRuntime.jsx(make, {
+              name: "NoAttribute"
+            }),
+        JsxRuntime.jsx(Playground$ReactInterfaceExample, {
+              name: "Interface"
+            }),
+        JsxRuntime.jsx(Playground$PropTypeInjectionExample, {
+              isHuman: true
+            }),
+        JsxRuntime.jsx(Playground$PropSpreadExample, {})
+      ]
+    });
+
+export {
+  AutomaticModeExample ,
+  ClassicModeExample ,
+  NoAttributeExample ,
+  ReactInterfaceExample ,
+  PropTypeInjectionExample ,
+  PropSpreadExample ,
+  root ,
+}
+```
+</CodeTab>
+
+### How to migrate to JSX v4?
+
+We provide a full [migration guide](/docs/react/latest/migrate-react) with all the details of an migration.
+
+Make sure to also check out the [rescript-react changelog](https://github.com/rescript-lang/rescript-react/blob/master/CHANGELOG.md) as well.
+
+## What's next?
+
+Our contributors are already one step ahead and are currently working on improvements for the next major v11 release. Things that are currently being explored:
+
+- Make uncurried functions the default. This will be a huge change in terms of how we do interop and will open completely new ways to interact with existing codebases. It will also allow us to improve tooling in ways that wouldn't have been possible in a curried language.
+- Explorations for a community "standard library" that goes beyond `Belt` and `Js.*`. This will also involve disabling / removing global "Stdlib" modules that shouldn't be used (e.g. `Array`, `List`, etc). 
+- New tooling to generate markdown from docstrings (module, type and value level). This will be super simple, but very effective.
+- Explorations for a [localized documentation page](https://forum.rescript-lang.org/t/translation-project-rescript-lang-org/4022) (currently in a slowed-down exploration phase, but we will be getting there)
+
+Check out the [v11](https://github.com/rescript-lang/rescript-compiler/issues?q=is%3Aopen+is%3Aissue+milestone%3Av11.0) milestone on our `rescript-lang` repo for more details on future improvements.
+
+## Acknowledgements
+
+As always, we want to thank our [contributors](https://github.com/rescript-lang/rescript-compiler/graphs/contributors?from=2019-11-24&to=2023-02-02&type=c) for building an amazing platform. Special thanks go out to [mununki](https://github.com/mununki) for building the new JSX v4 syntax. Amazing work!
+
+## That's it 
+
+We hope you enjoy the newest improvements as much as we do.
+
+In case there's any issues / problems, make sure to report bugs to [rescript-lang/rescript-compiler](https://github.com/rescript-lang/rescript-compiler) (language / syntax / jsx), [rescript-lang/rescript-react](https://github.com/rescript-lang/rescript-react) (React 16 / 18 binding) or [rescript-association/rescript-lang.org](https://github.com/rescript-association/rescript-lang.org) (documentation) repositories.
+
+Also feel free to visit the [ReScript forum](https://forum.rescript-lang.org/) to ask questions and connect with other ReScripters.
diff --git a/data/sidebar_manual_latest.json b/data/sidebar_manual_latest.json
index b75c6034c..fcd726d21 100644
--- a/data/sidebar_manual_latest.json
+++ b/data/sidebar_manual_latest.json
@@ -27,6 +27,7 @@
     "exception",
     "lazy-values",
     "promise",
+    "async-await",
     "module",
     "import-export",
     "attribute",
diff --git a/misc_docs/syntax/language_async.mdx b/misc_docs/syntax/language_async.mdx
new file mode 100644
index 000000000..616b9eff3
--- /dev/null
+++ b/misc_docs/syntax/language_async.mdx
@@ -0,0 +1,45 @@
+---
+id: "async"
+keywords: ["async"]
+name: "async"
+summary: "This is the `async` keyword."
+category: "languageconstructs"
+---
+
+**Since 10.1**
+
+Use the `async` keyword to make a function asynchronous. An async function may use the [await](#await) keyword to unwrap a promise value in a seamingly synchronous manner.
+
+### Example
+
+<CodeTab labels={["ReScript", "JS Output"]}>
+
+```res
+// Some fictive functionality that offers asynchronous network actions
+@val external fetchUserMail: string => promise<string> = "GlobalAPI.fetchUserMail"
+@val external sendAnalytics: string => promise<unit> = "GlobalAPI.sendAnalytics"
+
+// We use the `async` keyword to allow the use of `await` in the function body
+let logUserDetails = async (userId: string) => {
+  // We use `await` to fetch the user email from our fictive user endpoint
+  let email = await fetchUserMail(userId)
+
+  await sendAnalytics(`User details have been logged for ${userId}`)
+
+  Js.log(`Email address for user ${userId}: ${email}`)
+}
+```
+
+```js
+async function logUserDetails(userId) {
+  var email = await GlobalAPI.fetchUserMail(userId);
+  await GlobalAPI.sendAnalytics("User details have been logged for " + userId + "");
+  console.log("Email address for user " + userId + ": " + email + "");
+}
+```
+
+</CodeTab>
+
+### References
+
+- [Async / Await](/docs/manual/latest/async-await)
diff --git a/misc_docs/syntax/language_async_await.mdx b/misc_docs/syntax/language_async_await.mdx
new file mode 100644
index 000000000..e1b9a9a33
--- /dev/null
+++ b/misc_docs/syntax/language_async_await.mdx
@@ -0,0 +1,41 @@
+---
+id: "uncurried-function"
+keywords: ["async", "await"]
+name: "async/await"
+summary: "This is an `uncurried function`."
+category: "languageconstructs"
+---
+
+ReScript functions are curried by default, however in certain cases you may need an uncurried function. In these cases we add a `.` in the argument list.
+
+When calling uncurried functions, we must also include a `.` in the argument list.
+
+### Example
+
+<CodeTab labels={["ReScript", "JS Output"]}>
+
+```res
+let add = (. x, y) => {
+  x + y
+}
+
+let withCallback = (cb: (. int) => unit) => {
+  cb(. 1)
+}
+```
+
+```js
+function add(x, y) {
+  return (x + y) | 0;
+}
+
+function withCallback(cb) {
+  return cb(1);
+}
+```
+
+</CodeTab>
+
+### References
+
+- [Uncurried Function](/docs/manual/latest/function#uncurried-function)
diff --git a/misc_docs/syntax/language_await.mdx b/misc_docs/syntax/language_await.mdx
new file mode 100644
index 000000000..611993648
--- /dev/null
+++ b/misc_docs/syntax/language_await.mdx
@@ -0,0 +1,38 @@
+---
+id: "await"
+keywords: ["await"]
+name: "await"
+summary: "This is the `await` keyword."
+category: "languageconstructs"
+---
+
+**Since 10.1**
+
+Use the `await` within an `async` function to unwrap a promise value in a seamingly synchronous manner.
+
+### Example
+
+<CodeTab labels={["ReScript", "JS Output"]}>
+
+```res
+@val external queryMessagesApi: string => promise<string> = "global.queryMessagesApi"
+
+let fetchMessages = async () => {
+  let message = await queryMessagesApi("message-id-1")
+
+  Js.log(message)
+} 
+```
+
+```js
+async function fetchMessages(param) {
+  var message = await global.queryMessagesApi("message-id-1");
+  console.log(message);
+}
+```
+
+</CodeTab>
+
+### References
+
+- [Async / Await](/docs/manual/latest/async-await)
diff --git a/pages/community/roadmap.mdx b/pages/community/roadmap.mdx
index 11f46c4fd..82465113b 100644
--- a/pages/community/roadmap.mdx
+++ b/pages/community/roadmap.mdx
@@ -6,4 +6,16 @@ canonical: "/community/roadmap"
 
 # Roadmap
 
-TODO
+The ReScript development is an Open Source effort coordinated by individiual Open Source contributors, its creator [Hongbo Zhang](https://github.com/bobzhang) and members of the [ReScript Association](https://rescript-association.org).
+
+For latest development updates, please check out the [ReScript forum](https://forum.rescript-lang.org) development section and the [ReScript blog](/blog), or follow the relevant GitHub milestones on the rescript-compiler repository.
+
+## Current focus
+
+Major v11.0 release (see [v11 milestone](https://github.com/rescript-lang/rescript-compiler/issues?q=is%3Aopen+is%3Aissue+milestone%3Av11.0)).
+
+- Uncurried functions
+- Remove unnecessary Stdlib modules
+- Explore better Belt / Js module alternative, tooling for markdown documentation generation, and more.
+
+**Note:** Release goals may be subject of change.
diff --git a/pages/docs/manual/latest/async-await.mdx b/pages/docs/manual/latest/async-await.mdx
new file mode 100644
index 000000000..d5ae72fde
--- /dev/null
+++ b/pages/docs/manual/latest/async-await.mdx
@@ -0,0 +1,338 @@
+---
+title: "Async / Await"
+description: "Async / await for asynchronous operations"
+canonical: "/docs/manual/latest/async-await"
+---
+
+<!-- This prelude is used in many different followup examples, so we use it to shorten the noise of the example code. -->
+<div className="hidden">
+
+```res prelude
+@val external fetchUserMail: string => promise<string> = "GlobalAPI.fetchUserMail"
+@val external sendAnalytics: string => promise<unit> = "GlobalAPI.sendAnalytics"
+```
+
+</div>
+
+<!-- See https://github.com/cristianoc/rescript-compiler-experiments/pull/1#issuecomment-1131182023 for all async/await use-case examples -->
+
+# Async / Await
+
+**Since 10.1**
+
+ReScript comes with `async` / `await` support to make asynchronous, `Promise` based code easier to read and write. This feature is very similar to its JS equivalent, so if you are already familiar with JS' `async` / `await`, you will feel right at home.
+
+## How it looks 
+
+Let's start with a quick example to show-case the syntax:
+
+
+<CodeTab labels={["ReScript", "JS Output"]}>
+
+```res
+// Some fictive functionality that offers asynchronous network actions
+@val external fetchUserMail: string => promise<string> = "GlobalAPI.fetchUserMail"
+@val external sendAnalytics: string => promise<unit> = "GlobalAPI.sendAnalytics"
+
+// We use the `async` keyword to allow the use of `await` in the function body
+let logUserDetails = async (userId: string) => {
+  // We use `await` to fetch the user email from our fictive user endpoint
+  let email = await fetchUserMail(userId)
+
+  await sendAnalytics(`User details have been logged for ${userId}`)
+
+  Js.log(`Email address for user ${userId}: ${email}`)
+}
+```
+
+```js
+async function logUserDetails(userId) {
+  var email = await GlobalAPI.fetchUserMail(userId);
+  await GlobalAPI.sendAnalytics("User details have been logged for " + userId + "");
+  console.log("Email address for user " + userId + ": " + email + "");
+}
+```
+
+</CodeTab>
+
+As we can see above, an `async` function is defined via the `async` keyword right before the function's parameter list. In the function body, we are now able to use the `await` keyword to explicitly wait for a `Promise` value and assign its content to a let binding `email`.
+
+You will probably notice that this looks very similar to `async` / `await` in JS, but there are still a few details that are specific to ReScript. The next few sections will go through all the details that are specific to the ReScript type system.
+
+## Basics
+
+- You may only use `await` in `async` function bodies
+- `await` may only be called on a `promise` value
+- `await` calls are expressions, therefore they can be used in pattern matching (`switch`)
+- A function returning a `promise<'a>` is equivalent to an `async` function returning a value `'a` (important for writing signature files and bindings)
+- `promise` values and types returned from an `async` function don't auto-collapse into a "flat promise" like in JS (more on this later)
+
+
+## Types and `async` functions
+
+### `async` function type signatures
+
+Function type signatures (i.e defined in signature files) don't require any special keywords for `async` usage. Whenever you want to type an `async` function, use a `promise` return type.
+
+```resi
+// Demo.resi
+
+let fetchUserMail: string => promise<string>
+```
+
+The same logic applies to type definitions in `.res` files:
+
+```res example
+// function type
+type someAsyncFn = int => promise<int>
+
+// Function type annotation
+let fetchData: string => promise<string> = async (userId) => {
+  await fetchUserMail(userId)
+}
+```
+
+**BUT:** When typing `async` functions in your implementation files, you need to omit the `promise<'a>` type:
+
+```res
+// This function is compiled into a `string => promise<string>` type.
+// The promise<...> part is implicitly added by the compiler.
+let fetchData = async (userId: string): string => {
+  await fetchUserMail("test")
+}
+```
+
+For completeness reasons, let's expand the full signature and inline type definitions in one code snippet:
+
+```res
+// Note how the inline return type uses `string`, while the type definition uses `promise<string>`
+let fetchData: string => promise<string> = async (userId: string): string {
+  await fetchUserMail(userId)
+}
+```
+
+**Note:** In a practical scenario you'd either use a type signature, or inline types, not both at the same time. In case you are interested in the design decisions, check out [this discussion](https://github.com/rescript-lang/rescript-compiler/pull/5913#issuecomment-1359003870).
+
+### `async` uncurried functions
+
+The `async` keyword does also work for uncurried functions.
+
+```res
+let fetchData = async (. userId: string): string {
+  await fetchUserMail(userId)
+}
+```
+
+### Promises don't auto-collapse in async functions
+
+In JS, nested promises (i.e. `promise<promise<'a>>`) will automatically collapse into a flat promise (`promise<'a>`). This is not the case in ReScript. Use the `await` function to manually unwrap any nested promises within an `async` function instead.
+
+```res
+let fetchData = async (userId: string): string => {
+  // We can't just return the result of `fetchUserMail`, otherwise we'd get a
+  // type error due to our function return type of type `string`
+  await fetchUserMail(userId)
+}
+```
+
+## Error handling
+
+You may use `try / catch` or `switch` to handle exceptions during async execution.
+
+```res
+// For simulation purposes
+let authenticate = async () => {
+  raise(Js.Exn.raiseRangeError("Authentication failed."))
+}
+
+let checkAuth = async () => {
+  try {
+    await authenticate()
+  } catch {
+  | Js.Exn.Error(e) =>
+    switch Js.Exn.message(e) {
+    | Some(msg) => Js.log("JS error thrown: " ++ msg)
+    | None => Js.log("Some other exception has been thrown")
+    }
+  }
+}
+```
+
+Note how we are essentially catching JS errors the same way as described in our [Exception](exception#catch-rescript-exceptions-from-js) section.
+
+You may unify error and value handling in a single switch as well:
+
+```res
+let authenticate = async () => {
+  raise(Js.Exn.raiseRangeError("Authentication failed."))
+}
+
+let checkAuth = async () => {
+  switch await authenticate() {
+  | _ => Js.log("ok")
+  | exception Js.Exn.Error(e) => 
+    switch Js.Exn.message(e) {
+    | Some(msg) => Js.log("JS error thrown: " ++ msg)
+    | None => Js.log("Some other exception has been thrown")
+    }
+  }
+}
+```
+
+**Important:** When using `await` with a `switch`, always make sure to put the actual await call in the `switch` expression, otherwise your `await` error will not be caught.
+
+## Piping `await` calls
+
+You may want to pipe the result of an `await` call right into another function.
+This can be done by wrapping your `await` calls in a new `{}` closure.
+
+<CodeTab labels={["ReScript", "JS Output"]}>
+
+```res example
+@val external fetchUserMail: string => promise<string> = "GlobalAPI.fetchUserMail"
+
+let fetchData = async () => {
+  let mail = {await fetchUserMail("1234")}->Js.String2.toUpperCase
+  Js.log(`All upper-cased mail: ${mail}`)
+}
+```
+
+```js
+async function fetchData(param) {
+  var mail = (await GlobalAPI.fetchUserMail("1234")).toUpperCase();
+  console.log("All upper-cased mail: " + mail + "");
+}
+```
+
+</CodeTab>
+
+Note how the original closure was removed in the final JS output. No extra allocations!
+
+## Pattern matching on `await` calls
+
+`await` calls are just another kind of expression, so you can use `switch` pattern matching for more complex logic.
+
+<CodeTab labels={["ReScript", "JS Output"]}>
+
+```res example
+@val external fetchUserMail: string => promise<string> = "GlobalAPI.fetchUserMail"
+
+let fetchData = async () => {
+  switch (await fetchUserMail("user1"), await fetchUserMail("user2")) {
+  | (user1Mail, user2Mail) => {
+      Js.log("user 1 mail: " ++ user1Mail)
+      Js.log("user 2 mail: " ++ user2Mail)
+    }
+
+  | exception JsError(err) => Js.log2("Some error occurred", err)
+  }
+}
+```
+
+```js
+async function fetchData(param) {
+  var val;
+  var val$1;
+  try {
+    val = await GlobalAPI.fetchUserMail("user1");
+    val$1 = await GlobalAPI.fetchUserMail("user2");
+  }
+  catch (raw_err){
+    var err = Caml_js_exceptions.internalToOCamlException(raw_err);
+    if (err.RE_EXN_ID === "JsError") {
+      console.log("Some error occurred", err._1);
+      return ;
+    }
+    throw err;
+  }
+  console.log("user 1 mail: " + val);
+  console.log("user 2 mail: " + val$1);
+}
+```
+
+</CodeTab>
+
+## `await` multiple promises
+
+We can utilize the `Js.Promise2` module to handle multiple promises. E.g. let's use `Js.Promise2.all` to wait for multiple promises before continuing the program:
+
+```res
+let pauseReturn = (value, timeout) => {
+  Js.Promise2.make((~resolve, ~reject) => {
+    Js.Global.setTimeout(() => {
+      resolve(. value)
+    }, timeout)->ignore
+  })
+}
+
+let logMultipleValues = async () => {
+  let promise1 = pauseReturn("value1", 2000)
+  let promise2 = pauseReturn("value2", 1200)
+  let promise3 = pauseReturn("value3", 500)
+
+  let all = await Js.Promise2.all([promise1, promise2, promise3])
+
+  switch all {
+  | [v1, v2, v3] => Js.log(`All values: ${v1}, ${v2}, ${v3}`)
+  | _ => Js.log("this should never happen")
+  }
+}
+```
+
+## JS Interop with `async` functions
+
+`async` / `await` practically works with any function that returns a `promise<'a>` value. Map your `promise` returning function via an `external`, and use it in an `async` function as usual.
+
+Here's a full example of using the MDN `fetch` API, using `async` / `await` to simulate a login:
+
+```res
+// A generic Response type for typing our fetch requests
+module Response = {
+  type t<'data>
+  @send external json: t<'data> => promise<'data> = "json"
+}
+
+// A binding to our globally available `fetch` function. `fetch` is a
+// standardized function to retrieve data from the network that is available in
+// all modern browsers.
+@val @scope("globalThis")
+external fetch: (
+  string,
+  'params,
+) => promise<Response.t<{"token": Js.Nullable.t<string>, "error": Js.Nullable.t<string>}>> =
+  "fetch"
+
+// We now use our asynchronous `fetch` function to simulate a login.
+// Note how we use `await` with regular functions returning a `promise`.
+let login = async (email: string, password: string) => {
+  let body = {
+    "email": email,
+    "password": password,
+  }
+
+  let params = {
+    "method": "POST",
+    "headers": {
+      "Content-Type": "application/json",
+    },
+    "body": Js.Json.stringifyAny(body),
+  }
+
+  try {
+    let response = await fetch("https://reqres.in/api/login", params)
+    let data = await response->Response.json
+
+    switch Js.Nullable.toOption(data["error"]) {
+    | Some(msg) => Error(msg)
+    | None =>
+      switch Js.Nullable.toOption(data["token"]) {
+      | Some(token) => Ok(token)
+      | None => Error("Didn't return a token")
+      }
+    }
+  } catch {
+  | _ => Error("Unexpected network error occurred")
+  }
+}
+```
+
diff --git a/pages/docs/manual/latest/overview.mdx b/pages/docs/manual/latest/overview.mdx
index 9efad93a7..e9e3767f5 100644
--- a/pages/docs/manual/latest/overview.mdx
+++ b/pages/docs/manual/latest/overview.mdx
@@ -101,6 +101,15 @@ canonical: "/docs/manual/latest/overview"
 | `const f = function(arg) {...}` | `let f = (arg) => {...}`     |
 | `add(4, add(5, 6))`             | Same                         |
 
+### Async Function / Await
+
+| JavaScript                               | ReScript                           |
+| ---------------------------------------- | ---------------------------------- |
+| `async (arg) => {...}`                   | Same                               |
+| `async function named(arg) {...}`        | `let named = async (arg) => {...}` |
+| `await somePromise`                      | Same                               |
+| `async (arg): Promise<string> => {...}`  | `async (): string => {...}` (note the return type)|
+
 ### Blocks
 
 <table>
diff --git a/pages/docs/manual/latest/promise.mdx b/pages/docs/manual/latest/promise.mdx
index 619e4cfc4..c2b840b31 100644
--- a/pages/docs/manual/latest/promise.mdx
+++ b/pages/docs/manual/latest/promise.mdx
@@ -1,36 +1,121 @@
 ---
-title: "Async & Promise"
+title: "Promises"
 description: "JS Promise handling in ReScript"
 canonical: "/docs/manual/latest/promise"
 ---
 
-# Async & Promise
+# Promise
 
-Support for `async` and `await` is added in compiler version 10.1. The majority of existing code is based on promises. The new Promise API bindings make async code look better than with old promises.
+> **Note:** Starting from ReScript 10.1 and above, we recommend using [async / await](./async-await) when interacting with Promises.
 
-## Promise (new)
+## `promise` type
 
-Our up to date Promise bindings are currently not part of the the standard library. For now, please install them separately:
+**Since 10.1**
 
-```sh
-npm install @ryyppy/rescript-promise
+In ReScript, every JS promise is represented with the globally available `promise<'a>` type. For ReScript versions < 10.1, use its original alias `Js.Promise.t<'a>` instead.
+
+Here's a usage example in a function signature:
+
+```resi
+// User.resi file
+
+type user = {name: string}
+
+let fetchUser: string => promise<user>
 ```
 
-In your `bsconfig.json`:
+To work with promise values (instead of using `async` / `await`) you may want to use the built in `Js.Promise2` module. 
+
+## Js.Promise2
+
+A builtin module to create, chain and manipulate promises.
+
+> **Note:** This is an intermediate replacement for the `Js.Promise` module. It is designed to work with the `->` operator and should be used in favour of it's legacy counterpart. We are aware that the `Belt`, `Js` and `Js.xxx2` situation is confusing; a proper solution will hopefully be part of our upcoming `v11` release.
+
+### Creating a promise
+
+```res
+let p1 = Js.Promise2.make((~resolve, ~reject) => {
+  // We use uncurried functions for resolve / reject
+  // for cleaner JS output without unintended curry calls
+  resolve(. "hello world")
+})
+
+let p2 = Js.Promise2.resolve("some value")
 
-```json
-{
-  "bs-dependencies": ["@ryyppy/rescript-promise"]
+// You can only reject `exn` values for streamlined catch handling
+exception MyOwnError(string)
+let p3 = Js.Promise2.reject(MyOwnError("some rejection"))
+```
+
+### Access the contents and transform a promise
+
+```res
+let logAsyncMessage = () => {
+  open Js.Promise2
+  Js.Promise2.resolve("hello world")
+  ->then(msg => {
+    // then callbacks require the result to be resolved explicitly
+    resolve("Message: " ++ msg)
+  })
+  ->then(msg => {
+    Js.log(msg)
+
+    // Even if there is no result, we need to use resolve() to return a promise
+    resolve()
+  })
+  ->ignore // Requires ignoring due to unhandled return value
 }
 ```
 
-_Alternatively you may vendor the [`Promise.res` / `Promise.resi` files](https://github.com/ryyppy/rescript-promise/tree/master/src) files in your app codebase if you want to have more control._
+For comparison, the `async` / `await` version of the same code would look like this:
 
-You can find the APIs and full usage examples [here](https://github.com/ryyppy/rescript-promise#usage).
+```res
+let logAsyncMessage = async () => {
+  let msg = await Js.Promise2.resolve("hello world")
+  Js.log(`Message: ${msg}`)
+}
+```
+
+Needless to say, the async / await version offers better ergonomics and less opportunities to run into type issues.
+
+### Run multiple promises in parallel
+
+In case you want to launch multiple promises in parallel, use `Js.Promise2.all`:
+
+
+<CodeTab labels={["ReScript", "JS Output"]}>
+
+```res
+@val
+external fetchMessage: string => promise<string> = "global.fetchMessage"
+
+let logAsyncMessage = async () => {
+  let messages = await Js.Promise2.all([fetchMessage("message1"), fetchMessage("message2")])
+
+  Js.log(Js.Array2.joinWith(messages, ", "))
+}
+```
+
+```js
+async function logAsyncMessage(param) {
+  var messages = await Promise.all([
+        global.fetchMessage("message1"),
+        global.fetchMessage("message2")
+      ]);
+  console.log(messages.join(", "));
+}
+
+export {
+  logAsyncMessage ,
+}
+```
+
+</CodeTab>
 
-## Promise (legacy)
+## Js.Promise module (legacy - do not use)
 
-> **Note:** The `Js.Promise` bindings are following the outdated data-last convention from a few years ago. We kept those APIs for backwards compatibility, so for now please use [`rescript-promise`](https://github.com/ryyppy/rescript-promise) until we upstream the new bindings to our standard library.
+> **Note:** The `Js.Promise` bindings are following the outdated data-last convention from a few years ago. We kept those APIs for backwards compatibility. Either use `Js.Promise2` or a third-party promise binding instead.
 
 ReScript has built-in support for [JavaScript promises](api/js/promise). The 3 functions you generally need are:
 
diff --git a/plugins/cm-rescript-mode.js b/plugins/cm-rescript-mode.js
index 406381aa8..008a0f57e 100644
--- a/plugins/cm-rescript-mode.js
+++ b/plugins/cm-rescript-mode.js
@@ -36,7 +36,7 @@ CodeMirror.defineSimpleMode("rescript", {
       token: ["keyword", "keyword2", null, "def"]
     },
     {
-      regex: /(?:and|as|assert|catch|constraint|downto|else|exception|export|external|false|for|if|import|in|include|lazy|let|module|mutable|of|open|private|switch|to|true|try|type|when|while|with\!)\b/,
+      regex: /(?:and|as|assert|catch|async|await|constraint|downto|else|exception|export|external|false|for|if|import|in|include|lazy|let|module|mutable|of|open|private|switch|to|true|try|type|when|while|with\!)\b/,
       token: "keyword"
     },
     {
diff --git a/plugins/rescript-highlightjs.js b/plugins/rescript-highlightjs.js
index 7c37a4749..d1efcf34d 100644
--- a/plugins/rescript-highlightjs.js
+++ b/plugins/rescript-highlightjs.js
@@ -29,7 +29,7 @@ module.exports = function(hljs) {
     keyword:
       'and as assert catch constraint downto else exception export external false for ' +
       'if import in include lazy let module mutable of open private rec switch ' +
-      'to true try type when while with',
+      'to true try type when while with async await',
     // not reliable
      //built_in:
        //'array bool bytes char exn|5 float int int32 int64 list lazy_t|5 nativeint|5 ref string unit',
diff --git a/src/components/Markdown.res b/src/components/Markdown.res
index da20981c4..7adaf5cf0 100644
--- a/src/components/Markdown.res
+++ b/src/components/Markdown.res
@@ -150,7 +150,7 @@ module H2 = {
 module H3 = {
   @react.component
   let make = (~id, ~children) =>
-    <h3 className="group mt-8 mb-1 hl-4">
+    <h3 className="group mt-8 mb-4 hl-4">
       children
       <span className="ml-2">
         <Anchor id />
@@ -190,7 +190,7 @@ module InlineCode = {
   @react.component
   let make = (~children) =>
     <code
-      className="md-inline-code px-2 py-0.5 text-14 text-gray-60 font-mono rounded-sm bg-gray-10-tr border border-gray-90 border-opacity-5">
+      className="md-inline-code px-2 py-0.5  text-gray-60 font-mono rounded-sm bg-gray-10-tr border border-gray-90 border-opacity-5">
       children
     </code>
 }