diff --git a/website/versioned_docs/version-7.X/APIRef.DetoxCLI.md b/website/versioned_docs/version-7.X/APIRef.DetoxCLI.md
new file mode 100644
index 0000000000..158192493c
--- /dev/null
+++ b/website/versioned_docs/version-7.X/APIRef.DetoxCLI.md
@@ -0,0 +1,98 @@
+---
+id: version-7.X-APIRef.DetoxCLI
+title: Detox Command Line Tools (detox-cli)
+original_id: APIRef.DetoxCLI
+---
+
+`detox-cli` lets you operate Detox from command line.
+
+## Installation
+Install `detox-cli` globally via npm:
+
+```sh
+npm install -g detox-cli
+```
+
+## Usage
+```sh
+detox [options] [command]
+```
+
+## Commands:
+| Command | Description |
+| --- | --- |
+| [test](#test)              | Initiating your test suite |
+| [build](#build)            | Run the command defined in `configuration.build` |
+| [run-server](#run-server)  | Starts a standalone detox server |
+| [init](#init)              | Create initial e2e tests folder |
+| clean-framework-cache | Delete all compiled framework binaries from ~/Library/Detox, they will be rebuilt on 'npm install' or when running 'build-framework-cache'
+| build-framework-cache | Build Detox.framework to ~/Library/Detox. The framework cache is specific for each combination of Xcode and Detox versions
+| [help](#help)              | Display help for specific command |
+
+## Options:
+
+| Options | Description |
+| --- | --- |
+| -h<br>--help | Output usage information |
+
+## Commands
+
+### test
+Initiating your test suite
+
+`detox test [options]`
+
+
+
+| Option| Description |
+| --- | --- |
+| -h, --help                                    | output usage information |
+| -o, --runner-config \<config\>                | Test runner config file, defaults to 'e2e/mocha.opts' for mocha and 'e2e/config.json' for jest |
+| -l, --loglevel [value]                        | info, debug, verbose, silly, wss |
+| -c, -configuration \<device config\>          | Select a device configuration from your defined configurations,if not supplied, and there's only one configuration, detox will default to it |
+| -r, --reuse                                   | Reuse existing installed app (do not delete and re-tall) for a faster run. |
+| -u, --cleanup                                 | Shutdown simulator when test is over, useful for CI ipts, to make sure detox exists cleanly with no residue |
+| -d, --debug-synchronization \<value\>         | When an action/expectation takes a significant amount time use this option to print device synchronization status. The status will be printed if the ion takes more than [value]ms to complete |
+| -a, --artifacts-location \<path\>             | Artifacts destination path (currently contains only logs). For more details, please check the [Artifacts doc](APIRef.Artifacts.md#artifacts) |
+|-p, --platform [ios/android]		           | Run platform specific tests. Runs tests with invert grep on `:platform:`, e.g test with substring `:ios:` in its name will not run when passing `--platform android`
+|&#8195;&#8195;&#8195;&#8195;&#8195;&#8195;&#8195;&#8195;&#8195;&#8195;&#8195;&#8195;&#8195;&#8195;&#8195;&#8195;&#8195;&#8195;||
+
+
+
+### build
+Run a command defined in 'configuration.build'
+
+`detox build <command> [options]`
+
+| Option | Description |
+| --- | --- |
+| -h, --help                            |  output usage information |
+| -c, --configuration \<device config\> |  Select a device configuration from your defined configurations,if not supplied, and there's only one configuration, detox will default to it |
+|&#8195;&#8195;&#8195;&#8195;&#8195;&#8195;&#8195;&#8195;&#8195;&#8195;&#8195;&#8195;&#8195;&#8195;&#8195;&#8195;&#8195;&#8195;||
+
+
+### run-server
+Start a standalone detox server
+
+`detox run-server [options]`
+
+| Option | Description |
+| --- | --- |
+| -h, --help |  output usage information |
+
+
+### init
+Create initial e2e tests folder
+
+`detox init [options`
+
+| Option | Description |
+| --- | --- |
+| -h, --help   |  output usage information |
+| -r, --runner | Test runner (currently supports only `mocha`) |
+
+### help
+Display help for a command
+
+`detox help [command]`
+
diff --git a/website/versioned_docs/version-7.X/APIRef.DetoxObjectAPI.md b/website/versioned_docs/version-7.X/APIRef.DetoxObjectAPI.md
new file mode 100644
index 0000000000..5fdfae074a
--- /dev/null
+++ b/website/versioned_docs/version-7.X/APIRef.DetoxObjectAPI.md
@@ -0,0 +1,76 @@
+---
+id: version-7.X-APIRef.DetoxObjectAPI
+title: The `detox` Object
+original_id: APIRef.DetoxObjectAPI
+---
+
+`detox` is globally available in every test file, though currently it is only used in the setup/init file.
+
+>NOTE: detox is test runner independent, and we encourge you to choose your own test runner, but for the sake of demonstration we will use `mocha`'s syntax.
+
+### Methods
+
+- [`detox.init()`](#detox.init)
+- [`detox.cleanup()`](#detox.cleanup)
+
+### `detox.init()`
+The setup phase happens inside `detox.init()`. This is the phase where detox reads its configuration, starts a server, loads its expection library and starts a simulator.
+
+##### (if you're using mocha) In your `init.js` add:
+
+```js
+const config = require('../package.json').detox;
+
+before(async () => {
+  await detox.init(config);
+});
+```
+
+##### Explicit imports during initialization 
+Detox exports `device `, `expect`, `element`, `by` and `waitFor` as globals by default, if you want to control their initialization manually, set init detox with `initGlobals` set to `false`. This is useful when during E2E tests you also need to run regular expectations in node. jest `Expect` for instance, will not be overriden by Detox when this option is used.
+
+```js
+before(async () => {
+  await detox.init(config, {initGlobals: false});
+});
+```
+
+Then import them manually:
+
+```js
+const {device, expect, element, by, waitFor} = require('detox');
+```
+
+Use [this example](../examples/demo-react-native/e2eExplicitRequire) for initial setup
+
+
+
+#### Controlling first app intialization
+By default `await detox.init(config);` will launch the installed app. If you wish to control when your app is launched, add `{launchApp: false}` param to your init.
+
+```js
+const config = require('../package.json').detox;
+
+before(async () => {
+  await detox.init(config, {launchApp: false});
+});
+```
+
+>NOTE: Detox 6.X.X introduced a **breaking change** , setting `launchApp` to `false` by default. In order to prevent any breaking changes to your tests when you upgrade (and if you still would like `init` to launch the app for you) do the following:
+
+```js
+before(async () => {
+  await detox.init(config, {launchApp: true});
+});
+```
+
+### `detox.cleanup()`
+The cleanup phase should happen after all the tests have finished. This is the phase where detox-server shuts down. The simulator will also shut itself down if `--cleanup` flag is added to `detox test`
+
+##### (if you're using mocha) In your `init.js` add:
+
+```js
+after(async () => {
+  await detox.cleanup();
+});
+```
diff --git a/website/versioned_docs/version-7.X/APIRef.DeviceObjectAPI.md b/website/versioned_docs/version-7.X/APIRef.DeviceObjectAPI.md
new file mode 100644
index 0000000000..2e7d9e9754
--- /dev/null
+++ b/website/versioned_docs/version-7.X/APIRef.DeviceObjectAPI.md
@@ -0,0 +1,220 @@
+---
+id: version-7.X-APIRef.DeviceObjectAPI
+title: The `device` Object
+original_id: APIRef.DeviceObjectAPI
+---
+
+`device` is globally available in every test file, it enables control over the current attached device (currently only simulators are supported).
+
+### Methods
+
+- [`device.launchApp()`](#devicelaunchappparams)
+- [`device.relaunchApp()` **Deprecated**](#devicerelaunchappparams)
+- [`device.terminateApp()`](#deviceterminateapp)
+- [`device.reloadReactNative()`](#devicereloadreactnative)
+- [`device.sendToHome()`](#devicesendtohome)
+- [`device.installApp()`](#deviceinstallapp)
+- [`device.uninstallApp()`](#deviceuninstallapp)
+- [`device.openURL(url)`](#deviceopenurlurl-sourceappoptional)
+- [`device.sendUserNotification(params)`](#devicesendusernotificationparams)
+- [`device.setOrientation(orientation)`](#devicesetorientationorientation)
+- [`device.setLocation(lat, lon)`](#devicesetlocationlat-lon)
+- [`device.setURLBlacklist([urls])`](#deviceseturlblacklisturls)
+- [`device.enableSynchronization()`](#deviceenablesynchronization)
+- [`device.disableSynchronization()`](#devicedisablesynchronization)
+- [`device.resetContentAndSettings()`](#deviceresetcontentandsettings)
+- [`device.getPlatform()`](#devicegetplatform)
+
+### `device.launchApp(params)`
+Launch the app defined in the current [`configuration`](APIRef.Configuration.md).
+
+**Options:** 
+
+##### 1. Restart the app
+Terminate the app and launch it again. 
+If set to `false`, the simulator will try to bring app from background, if the app isn't running, it will launch a new instance. default is `false`
+
+```js
+await device.launchApp({newInstance: true});
+```
+
+##### 2. Set runtime permissions
+Grant or deny runtime permissions for your application. 
+
+```js
+await device.launchApp({permissions: {calendar: 'YES'}});
+```
+Detox uses [AppleSimUtils](https://github.com/wix/AppleSimulatorUtils) on iOS to support this functionality. Read about the different types of permissions and how to set them in AppleSimUtils' Readme.
+Check out Detox's [own test suite](../detox/test/e2e/l-permissions.js)
+
+##### 3. Launch from URL
+Mock opening the app from URL to test your app's deep link handling mechanism.
+
+```js
+await device.launchApp({url: url});
+```
+###### Mock opening from a URL when app is not running
+```js
+await device.launchApp({url: url, newInstance: true});
+```
+This will launch a new instance of the app and handle the deep link.
+
+######  Mock opening from a URL when app is in background
+
+```js
+await device.launchApp({url: url, newInstance: false});
+```
+This will launch the app from background and handle the deep link.
+
+Read more in [Mocking Open From URL](APIRef.MockingOpenFromURL.md) section.
+
+##### 4. Launch from user notifications
+
+```js
+await device.launchApp({userNotification: notification});
+```
+
+###### Mock receiving a notifications when app is not running
+```js
+await device.launchApp({userNotification: notification, newInstance: true});
+```
+This will launch a new instance of the app and handle the notification.
+
+######  Mock receiving a notifications when app is in background
+
+```js
+await device.launchApp({userNotification: notification, newInstance: false});
+```
+This will launch the app from background and handle the notification.
+
+Read more in [Mocking User Notifications](APIRef.MockingUserNotifications.md) section.
+
+##### 5. Launch into a fresh installation 
+A flag that enables relaunching into a fresh installation of the app (it will uninstall and install the binary again), default is `false`.
+
+```js
+await device.launchApp({delete: true});
+```
+
+##### 6. Additional launch arguments
+Detox can start the app with additional launch arguments
+
+```js
+await device.launchApp({launchArgs: {arg1: 1, arg2: "2"}});
+```
+
+The added `launchArgs` will be passed through the launch command to the device and be accessible via `[[NSProcessInfo processInfo] arguments]`
+
+### `device.relaunchApp(params)`
+**Deprecated** Use `device.launchApp(params)` instead. This method is now calling `launchApp({newInstance: true})` for backwards compatibility, it will be removed in Detox 6.X.X.<Br>
+Kill and relaunch the app defined in the current [`configuration`](APIRef.Configuration.md).
+
+### `device.terminateApp()`
+By default, `terminateApp()` with no params will terminate the app file defined in the current [`configuration`](APIRef.Configuration.md).
+
+To terminate another app, specify its bundle id
+
+```js
+await device.terminateApp('other.bundle.id');
+```
+
+### `device.sendToHome()`
+Send application to background by bringing `com.apple.springboard` to the foreground.<br>
+Combining `sendToHome()` with `launchApp({newInstance: false})` will simulate app coming back from background.<br>
+Check out Detox's [own test suite](../detox/test/e2e/f-simulator.js)
+
+```js
+await device.sendToHome();
+await device.launchApp({newInstance: false});
+// app returned from background, do stuff
+```
+Check out Detox's [own test suite](../detox/test/e2e/f-device.js)
+
+### `device.reloadReactNative()`
+If this is a react native app, reload react native JS bundle. This action is much faster than `device.relaunchApp()`, and is recommended if you just need to reset your react native logic.
+
+### `device.installApp()`
+By default, `installApp()` with no params will install the app file defined in the current [`configuration`](APIRef.Configuration.md).
+
+To install another app, specify its path
+
+```js
+await device.installApp('path/to/other/app');
+```
+
+### `device.uninstallApp()`
+By default, `uninstallApp()` with no params will uninstall the app defined in the current [`configuration`](APIRef.Configuration.md).
+
+To uninstall another app, specify its bundle id
+
+```js
+await device.installApp('other.bundle.id');
+```
+
+### `device.openURL({url, sourceApp[optional]})`
+Mock opening the app from URL. `sourceApp` is an optional parameter to specify source application bundle id.<br>
+Read more in [Mocking Open From URL](APIRef.MockingOpenFromURL.md) section.<br>
+Check out Detox's [own test suite](../detox/test/e2e/n-deep-links.js)
+
+### `device.sendUserNotification(params)`
+Mock handling of received user notification when app is in foreground.<br>
+Read more in [Mocking User Notifications](APIRef.MockingUserNotifications.md) section.<br>
+Check out Detox's [own test suite](../detox/test/e2e/k-user-notifications.js)
+
+### `device.setOrientation(orientation)`
+Takes `"portrait"` or `"landscape"` and rotates the device to the given orientation.
+Currently only available in the iOS Simulator.<br>
+Check out Detox's [own test suite](../detox/test/e2e/f-device.js)
+
+### `device.setLocation(lat, lon)`
+>Note: `setLocation` is dependent on `fbsimctl`. if `fbsimctl` is not installed, the command will fail, asking for it to be installed.
+Sets the simulator location to the given latitude and longitude.
+```js
+await device.setLocation(32.0853, 34.7818);
+```
+
+### `device.setURLBlacklist([urls])`
+
+Disable [EarlGrey's network synchronization mechanism](https://github.com/google/EarlGrey/blob/master/docs/api.md#network) on preffered endpoints. Usful if you want to on skip over synchronizing on certain URLs.
+
+```js
+await device.setURLBlacklist(['.*127.0.0.1.*']);
+```
+
+```js
+await device.setURLBlacklist(['.*my.ignored.endpoint.*']);
+```
+
+### `device.enableSynchronization()`
+Enable [EarlGrey's synchronization mechanism](https://github.com/google/EarlGrey/blob/master/docs/api.md#synchronization
+) (enabled by default). **This is being reset on every new instance of the app.**
+```js
+await device.enableSynchronization();
+```
+
+
+### `device.disableSynchronization()`
+Disable [EarlGrey's synchronization mechanism](https://github.com/google/EarlGrey/blob/master/docs/api.md#synchronization
+) (enabled by default) **This is being reset on every new instance of the app.**
+
+```js
+await device.disableSynchronization();
+```
+
+
+### `device.resetContentAndSettings()`
+Resets the Simulator to clean state (like the Simulator > Reset Content and Settings... menu item), especially removing
+previously set permissions.
+
+```js
+await device.resetContentAndSettings();
+```
+
+### `device.getPlatform()`
+Returns the current device, `ios` or `android`.
+
+```js
+if (device.getPlatform() === 'ios') {
+  await expect(loopSwitch).toHaveValue('1');
+}
+```
diff --git a/website/versioned_docs/version-7.X/APIRef.waitFor.md b/website/versioned_docs/version-7.X/APIRef.waitFor.md
new file mode 100644
index 0000000000..92213b1184
--- /dev/null
+++ b/website/versioned_docs/version-7.X/APIRef.waitFor.md
@@ -0,0 +1,100 @@
+---
+id: version-7.X-APIRef.waitFor
+title: Manual Synchronization Using `waitFor`
+original_id: APIRef.waitFor
+---
+
+In most cases, tests should be automatically synchronized with the app. When synchronization doesn't work, you have a fail-safe by using `waitFor`. This API polls using the given expectation continuously until the expectation is met. Use manual synchronization with `waitFor` only as a **last resort**. Polling for expectations isn't exactly a best practice.
+
+Test async code with waitFor.<br>
+**Hang the test until an expectation is met.**
+
+### Methods
+
+- [`.toBeVisible()`](#tobevisible)
+- [`.toBeNotVisible()`](#tobenotvisible)
+- [`.toExist()`](#toexist)
+- [`.toNotExist()`](#tonotexist)
+- [`.toHaveText()`](#tohavetexttext)
+- [`.toHaveValue()`](#tohavevaluevalue)
+- [`.withTimeout()`](#withtimeoutmillis)
+- [`.whileElement()`](#whileelementelement)
+
+>NOTE: Every `waitFor` call must set a timeout using `withTimeout()`. Calling `waitFor` without setting a timeout **will do nothing**.
+
+>NOTE: `waitFor` will not throw when reaching timeout, instead it will just continue to the next line. To make sure your tests work as you expect them to add `expect()` at the following line.  
+
+### `toBeVisible()`
+Test will hang until expectation is met or a timeout has occurred. Should be accompanied with [`expect.toBeVisible()`](APIRef.Expect.md#tobevisible)<br>
+Wait for the view to be at least 75% visible.
+
+```js
+await waitFor(element(by.id('UniqueId204'))).toBeVisible().withTimeout(2000);
+await expect(element(by.id('UniqueId204'))).toBeVisible();
+```
+
+### `toBeNotVisible()`
+Test will hang until expectation is met or a timeout has occurred. Should be accompanied with [`expect.toBeNotVisible()`](APIRef.Expect.md#tobenotvisible)<br>
+Wait for the view to not be visible.
+
+```js
+await waitFor(element(by.id('UniqueId205'))).toBeNotVisible().withTimeout(2000);
+await expect(element(by.id('UniqueId205'))).toBeNotVisible();
+```
+
+### `toExist()`
+Test will hang until expectation is met or a timeout has occurred. Should be accompanied with [`expect.toExist()`](APIRef.Expect.md#toexist)<br>
+Wait for the view to exist in the UI hierarchy.
+
+```js
+await waitFor(element(by.id('UniqueId205'))).toExist().withTimeout(2000);
+await expect(element(by.id('UniqueId205'))).toExist();
+```
+
+### `toNotExist()`
+Test will hang until expectation is met or a timeout has occurred. Should be accompanied with [`expect.toNotExist()`](APIRef.Expect.md#tonotexist)<br>
+Wait for the view to not exist in the UI hierarchy.
+
+```js
+await waitFor(element(by.id('RandomJunk959'))).toNotExist().withTimeout(2000);
+await expect(element(by.id('RandomJunk959'))).toNotExist();
+```
+
+### `toHaveText(text)`
+Test will hang until expectation is met or a timeout has occurred. Should be accompanied with [`expect.toHaveText(text)`](APIRef.Expect.md#tohavetexttext)<br>
+- In React Native apps, expect UI component of type `<Text>` to have text.
+- In native iOS apps, expect UI elements of type UIButton, UILabel, UITextField or UITextViewIn to have inputText with text.
+
+```js
+await waitFor(element(by.id('UniqueId204'))).toHaveText('I contain some text').withTimeout(2000);
+await expect(element(by.id('UniqueId204'))).toHaveText('I contain some text');
+```
+
+### `toHaveValue(value)`
+Test will hang until expectation is met or a timeout has occurred. Should be accompanied with [`expect.toHaveValue(value)`](APIRef.Expect.md#tohavevaluevalue)<br>
+
+- In React Native apps, expect UI component to have [`testID`](https://facebook.github.io/react-native/docs/view.html#testid) with that id.
+- In native iOS apps, expect UI element to have accesibilityIdentifier with that id.
+
+```js
+await waitFor(element(by.id('uniqueId'))).toHaveValue('Some value').withTimeout(2000);
+await expect(element(by.id('uniqueId'))).toHaveValue('Some value');
+```
+
+
+### `withTimeout(millis)`
+Waits for the condition to be met until the specified time (millis) have elapsed.
+
+```js
+await waitFor(element(by.id('UniqueId336'))).toExist().withTimeout(2000);
+await expect(element(by.id('UniqueId336'))).toExist();
+```
+
+
+### `whileElement(element)`
+Performs the action repeatedly on the element until an expectation is met.
+ 
+```js
+await waitFor(element(by.text('Text5'))).toBeVisible().whileElement(by.id('ScrollView630')).scroll(50, 'down');
+await expect(element(by.text('Text5'))).toBeVisible();
+```
diff --git a/website/versioned_docs/version-7.X/Guide.Contributing.md b/website/versioned_docs/version-7.X/Guide.Contributing.md
new file mode 100644
index 0000000000..fc8860ce16
--- /dev/null
+++ b/website/versioned_docs/version-7.X/Guide.Contributing.md
@@ -0,0 +1,135 @@
+---
+id: version-7.X-Guide.Contributing
+title: Contributing
+original_id: Guide.Contributing
+---
+
+## Prerequisites
+
+### Install `node` v7.6 or higher (to support async-await natively)
+
+```
+brew install node
+```
+
+### Install global node libraries `lerna` and `react-native-cli`
+
+```sh
+npm install -g lerna
+npm install -g react-native-cli
+```
+
+For all the internal projects (detox, detox-server, detox-cli, demos, test) `lerna` will create symbolic links in `node_modules` instead of `npm` copying the content of the projects. This way, any change you do on any code is there immediately. There is no need to update node modules or copy files between projects.
+
+### Install `xcpretty`
+
+```sh
+gem install xcpretty
+```
+
+Alternatively, run `scripts/install.ios.sh` / `scripts/install.android.sh` to install all prerequisites.
+
+## Detox
+
+### Clone Detox and submodules
+
+```sh
+git clone git@github.com:wix/detox.git
+cd detox
+git submodule update --init --recursive
+```
+(this makes sure all git submodule dependencies are properly checked out)
+
+### Installing and linking internal projects
+
+```sh
+scripts/bootstrap.sh
+```
+
+### Building
+
+```sh
+lerna run build
+```
+
+### Testing
+
+### 1. Unit tests
+
+```sh
+lerna run test
+```
+
+Detox JS code is 100% test covered and is set to break the build if coverage gets below, so make sure you run unit tests (`lerna run test`) locally before pushing.
+
+Alternatively, to run only the JS tests, run the following from the `detox/detox` directory:
+
+```sh
+npm run unit
+-or-
+npm run unit:watch
+```
+
+#### How to read the coverage report
+After running the tests, jest will create a coverage report.
+
+```sh
+cd detox
+open coverage/lcov-report/index.html
+```
+
+### 2. Running Detox e2e coverage tests
+Detox has a suite of e2e tests to test its own API while developing (and for regression). The way we do is is by maintaining a special application that is "tested" against Detox's API, but essentially, it's the API that is tested, not the app.
+To run the e2e tests, go to `detox/detox/test`
+
+```sh
+cd detox/test
+```
+
+
+```sh
+npm run build
+```
+
+To run the e2e tests, after the application was built.
+
+#### iOS
+```sh
+npm run build:ios
+npm run e2e:ios
+```
+
+#### Android
+```sh
+npm run build:android
+npm run e2e:android
+```
+
+### 3. Android Native tests
+
+0. Install Java and Android SDK 25
+1. In `detox/android` run `./gradlew install` run
+
+	```sh
+	./gradlew test
+	```
+
+### 4. Code Generation
+
+We are using a code generator based on `babel` and `objective-c-parser` to generate a Javascript Interface for `EarlGrey` (the testing library we use on iOS).
+This interface allows us to call Objective-C methods through the WebSocket connection directly on the testing device. 
+
+This approach is currently limited to `GREYActions`, but we plan on extending it to cover more functionality of `EarlGrey`.
+You may see the generated files under [`detox/src/ios/earlgreyapi/`](../detox/src/ios/earlgreyapi).
+
+What happens under the hood can be seen in [`generation/`](../generation); it boils down to these steps for each input file:
+
+1. Convert Objective-C header file in a JSON Representation
+2. Build an Abstract Syntax Tree: Create Class & for each method
+    1. Check if the type can be expressed simpler (`NSString *` => `NSString`)
+    2. Get the type checks for the arguments
+    2. Get the return value
+    4. Assemble type checks and return value to complete function
+3. Generate the code for the syntax tree & add helpers
+
+If you would like to extend the code generation, please make sure to read the [`generation/README.md`](../generation#generation)
diff --git a/website/versioned_docs/version-7.X/Guide.Jest.md b/website/versioned_docs/version-7.X/Guide.Jest.md
new file mode 100644
index 0000000000..4cd9a5605d
--- /dev/null
+++ b/website/versioned_docs/version-7.X/Guide.Jest.md
@@ -0,0 +1,76 @@
+---
+id: version-7.X-Guide.Jest
+title: Jest
+original_id: Guide.Jest
+---
+
+## Usage
+
+### 0. Use the [Getting Started](Introduction.GettingStarted.md) Guide to set up detox
+
+Except that you need to skip the install mocha step.
+
+### 1. Install Jest
+
+```sh
+npm install --save-dev jest
+```
+
+### 2. Remove mocha specific files
+
+You should remove `e2e/mocha.opts`, you no longer need it.
+
+### 3. Replace generated detox setup file (e2e/init.js)
+
+```js
+const detox = require('detox');
+const config = require('../package.json').detox;
+
+// Set the default test timeout of 120s
+jest.setTimeout(120000);
+
+beforeAll(async () => {
+  await detox.init(config);
+});
+
+afterAll(async () => {
+  await detox.cleanup();
+});
+```
+
+### 4. Configure Detox to run with Jest
+
+Add a Jest config file `e2e/config.json`:
+
+```json
+{
+  "setupTestFrameworkScriptFile" : "./init.js"
+}
+```
+
+
+In `package.json`:
+
+```json
+"scripts": {
+    "test:e2e": "detox test -c ios.sim.debug",
+    "test:e2e:build": "detox build"
+},
+"detox": {
+  "test-runner": "jest",
+  "runner-config": "e2e/config.json"
+  ...
+}
+```
+
+### Writing Tests
+
+There are some things you should notice:
+
+- Don't worry about mocks being used, detox works on the compiled version of your app.
+- Detox exposes it's primitives (`expect`, `device`, ...) globally, it will override Jest's global `expect` object.
+
+## How to run unit test and E2E tests in the same project
+
+- If you have a setup file for the unit tests pass `./jest/setup` implementation into your unit setup.
+- Call your E2E tests using `detox-cli`: `detox test`
diff --git a/website/versioned_docs/version-7.X/Introduction.Android.md b/website/versioned_docs/version-7.X/Introduction.Android.md
new file mode 100644
index 0000000000..e063c9d8c9
--- /dev/null
+++ b/website/versioned_docs/version-7.X/Introduction.Android.md
@@ -0,0 +1,137 @@
+---
+id: version-7.X-Introduction.Android
+title: Detox for Android
+original_id: Introduction.Android
+---
+
+## Setup
+Detox 7 was updated to support Android gradle plugin 3.0.0. This is a breaking change that makes it impossible to support previous Android gradle plugin versions.
+
+https://developer.android.com/studio/build/gradle-plugin-3-0-0-migration.html
+
+For older Android gradle plugin support use `detox@6.x.x` instead ([previous setup guide here](https://github.com/wix/detox/blob/97654071573053def90e8207be8eba011408f977/docs/Introduction.Android.md)).<br>
+**Detox 6 will not continue to be updated, to continue getting updates and features, update your Android gradle config and migrate to Detox 7.**
+
+### 1. Do the initial setup described in the Getting Started Guide
+
+- [Getting Started](Introduction.GettingStarted.md)
+
+### 2. Add Detox dependency to an Android project
+
+In `android/settings.gradle` add:
+
+```gradle
+include ':detox'
+project(':detox').projectDir = new File(rootProject.projectDir, '../node_modules/detox/android/detox')
+```
+
+In `android/app/build.gradle` add this to `defaultConfig` section:
+
+```gradle
+  defaultConfig {
+      ...
+      testBuildType System.getProperty('testBuildType', 'debug')  //this will later be used to control the test apk build type
+      missingDimensionStrategy "minReactNative", "minReactNative46" //read note
+      testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
+      ...
+  }
+```
+Please be aware that the `minSdkVersion` needs to be at least 18.
+
+> ###### Choosing the right build type (in missingDimensionStrategy)
+>Detox runs on multiple React Native versions, choose the correct build type to support the version you use.<br>
+>**Available versions:**
+>
+>* `minReactNative44`: Support for React Native 0.44-0.45
+>* `minReactNative46`: Support for React Native 0.46+
+
+
+In `android/app/build.gradle` add this in `dependencies` section:
+
+```gradle
+dependencies {
+	...
+    androidTestImplementation(project(path: ":detox"))
+    androidTestImplementation 'junit:junit:4.12'
+    androidTestImplementation 'com.android.support.test:runner:1.0.1'
+    androidTestImplementation 'com.android.support.test:rules:1.0.1'
+    ...
+}
+```
+
+And in the same file you need to add this under `allprojects > repositories`:
+
+```gradle
+buildscript {
+    repositories {
+	     ...
+        google()
+        ...
+    }
+}
+```
+
+### 3. Create Android Test class
+
+You need to add the file `android/app/src/androidTest/java/com/[your.package]/DetoxTest.java` and fill it like [this](../detox/test/android/app/src/androidTest/java/com/example/DetoxTest.java), expect that you need to change the package to your projects name.
+
+### 4. Add Android configuration
+
+Add this part to your `package.json`:
+
+```json
+"detox" : {
+    "configurations": {
+        "android.emu.debug": {
+            "binaryPath": "android/app/build/outputs/apk/debug/app-debug.apk",
+            "build":
+            "cd android && ./gradlew assembleDebug assembleAndroidTest -DtestBuildType=debug && cd ..",
+            "type": "android.emulator",
+            "name": "Nexus_5X_API_24"
+        },
+        "android.emu.release": {
+            "binaryPath": "android/app/build/outputs/apk/release/app-release.apk",
+            "build":
+            "cd android && ./gradlew assembleRelease assembleAndroidTest -DtestBuildType=release && cd ..",
+            "type": "android.emulator",
+            "name": "Nexus_5X_API_26"
+        }
+    }
+}
+```
+Pay attention to `-DtestBuildType`, set either to `debug` or `release` according to the main apk type.
+
+
+Following device types could be used to control Android devices:
+
+`android.emulator`. Boot stock SDK emulator with provided `name`, for example `Nexus_5X_API_25`. After booting connect to it.
+
+`android.attached`. Connect to already-attached android device. The device should be listed in the output of `adb devices` command under provided `name`.
+Use this type to connect to Genymotion emulator.
+
+### 5. Run the tests
+
+Using the `android.emu.debug` configuration from above, you can invoke it in the standard way.
+
+```sh
+detox test -c android.emu.debug
+```
+
+## Troubleshooting
+
+### Problem: `Duplicate files copied in ...`
+
+If you get an error like this:
+
+```sh
+Execution failed for task ':app:transformResourcesWithMergeJavaResForDebug'.
+> com.android.build.api.transform.TransformException: com.android.builder.packaging.DuplicateFileException: Duplicate files copied in APK META-INF/LICENSE
+```
+
+You need to add this to the `android` section of your `android/app/build.gradle`:
+
+```gradle
+packagingOptions {
+    exclude 'META-INF/LICENSE'
+}
+```
diff --git a/website/versioned_docs/version-7.X/Introduction.GettingStarted.md b/website/versioned_docs/version-7.X/Introduction.GettingStarted.md
new file mode 100644
index 0000000000..3172b998d3
--- /dev/null
+++ b/website/versioned_docs/version-7.X/Introduction.GettingStarted.md
@@ -0,0 +1,154 @@
+---
+id: version-7.X-Introduction.GettingStarted
+title: Getting Started
+original_id: Introduction.GettingStarted
+---
+
+This is a step-by-step guide for adding Detox to your React Native project.
+
+> TIP: You can also check out this [awesome tutorial](https://medium.com/@bogomolnyelad/how-to-test-your-react-native-app-like-a-real-user-ecfc72e9b6bc) on Medium with video by [@bogomolnyelad](https://medium.com/@bogomolnyelad)
+
+<br>
+
+## Prerequisites
+
+Running Detox (on iOS) requires the following:
+
+* Mac with macOS (at least macOS El Capitan 10.11)
+
+* Xcode 8.3+ with Xcode command line tools
+> TIP: Verify Xcode command line tools is installed by typing `gcc -v` in terminal (shows a popup if not installed)
+
+* A working [React Native](https://facebook.github.io/react-native/docs/getting-started.html) app you want to test
+
+<br>
+
+## Step 1: Install dependencies
+
+#### 1. Install the latest version of [Homebrew](http://brew.sh)
+
+Homebrew is a package manager for macOS, we'll need it to install other command line tools.
+
+> TIP: Verify it works by typing in terminal `brew -h` to output list of available commands
+
+#### 2. Install [Node.js](https://nodejs.org/en/)
+
+Node is the JavaScript runtime Detox will run on. **Install Node 7.6.0 or above for native async-await support**
+
+ ```sh
+ brew update && brew install node
+ ```
+
+> TIP: Verify it works by typing in terminal `node -v` to output current node version, should be higher than 7.6.0
+
+#### 3. Install [appleSimUtils](https://github.com/wix/AppleSimulatorUtils)
+
+A collection of utils for Apple simulators, Detox uses it communicate with the simulator.
+
+```sh
+brew tap wix/brew
+brew install --HEAD applesimutils
+```
+
+> TIP: Verify it works by typing in terminal `applesimutils` to output the tool help screen
+
+#### 4. Install Detox command line tools (detox-cli)
+
+This package makes it easier to operate Detox from the command line. `detox-cli` should be installed globally, enabling usage of the command line tools outside of your npm scripts.
+
+  ```sh
+  npm install -g detox-cli
+  ```
+> TIP: Verify it works by typing in terminal `detox -h` to output the list of available commands
+
+<br>
+
+## Step 2: Add Detox to your project
+
+#### 1. Install detox
+
+Go to the root folder of your React Native app (where `package.json` is found):
+
+```sh
+npm install detox --save-dev
+```
+
+#### 2. Install mocha
+
+You can use any JavaScript test runner
+- [Jest](Guide.Jest.md)
+- [Mocha](https://mochajs.org/) is a good one we recommend:
+
+```sh
+npm install mocha --save-dev
+```
+
+#### 3. Add Detox config to package.json
+
+The basic configuration for Detox should be in your `package.json` file under the `detox` property:
+
+```json
+"detox": {
+  "configurations": {
+    "ios.sim.debug": {
+      "binaryPath": "ios/build/Build/Products/Debug-iphonesimulator/example.app",
+      "build": "xcodebuild -project ios/example.xcodeproj -scheme example -configuration Debug -sdk iphonesimulator -derivedDataPath ios/build",
+      "type": "ios.simulator",
+      "name": "iPhone 7"
+    }
+  }
+}
+```
+
+In the above configuration example, change `example` to your actual project name. Under the key `"binaryPath"`, `example.app` should be `<your_project_name>.app`. Under the key `"build"`, `example.xcodeproj` should be `<your_project_name>.xcodeproj` and `-scheme example` should be `-scheme <your_project_name>`.
+
+For iOS apps in a workspace (eg: CocoaPods) use `-workspace ios/example.xcworkspace` instead of `-project`.
+
+Also make sure the simulator model specified under the key `"name"` (`iPhone 7` above) is actually available on your machine (it was installed by Xcode). Check this by typing `xcrun simctl list` in terminal to display all available simulators.
+
+> TIP: To test a release version, replace 'Debug' with 'Release' in the binaryPath and build properties. For full configuration options see Configuration under the API Reference.
+
+<br>
+
+## Step 3: Create your first test (using mocha test runner)
+
+You can do this automatically by running:
+
+```sh
+detox init
+```
+
+Or you can do this manually instead by following these steps:
+
+* Create an `e2e` folder in your project root
+* Create `mocha.opts` file inside with this [content](/examples/demo-react-native/e2e/mocha.opts)
+* Create `init.js` file inside with this [content](/examples/demo-react-native/e2e/init.js)
+* Create your first test `firstTest.spec.js` inside with content similar to [this](/examples/demo-react-native/e2e/example.spec.js)
+
+> TIP: Detox is not tightly coupled to Mocha or this directory structure, both are just a recommendation and are easy to replace without touching the internal implementation of Detox itself.
+
+<br>
+
+## Step 4: Build your app and run Detox tests
+
+#### 1. Build your app
+
+Use the Detox command line tools to build your project easily:
+
+```sh
+detox build
+```
+
+> TIP: Notice that the actual build command was specified in the Detox configuration above
+
+#### 2. Run the tests (finally)
+
+Use the Detox command line tools to test your project easily:
+
+```sh
+detox test
+```
+
+That's it. Your first failing Detox test is running!
+
+Next, we'll go over usage and how to make this test [actually pass](Introduction.WritingFirstTest.md).
diff --git a/website/versioned_docs/version-7.X/README.md b/website/versioned_docs/version-7.X/README.md
new file mode 100644
index 0000000000..e2121c829a
--- /dev/null
+++ b/website/versioned_docs/version-7.X/README.md
@@ -0,0 +1,57 @@
+---
+id: version-7.X-README
+title: detox
+sidebar_label: Overview
+original_id: README
+---
+
+# Detox Documentation
+
+## Introduction
+
+- [Getting Started](Introduction.GettingStarted.md)
+- [Writing Your First Passing Test](Introduction.WritingFirstTest.md)
+- [Adding Android](Introduction.Android.md)
+- [How Detox Works](Introduction.HowDetoxWorks.md)
+- [Recommended Workflows With Detox](Introduction.Workflows.md)
+
+## API Reference
+
+- [Detox Configuration](APIRef.Configuration.md)
+- [The `detox` Object](APIRef.DetoxObjectAPI.md)
+- [The `device` Object](APIRef.DeviceObjectAPI.md)
+- [Test Lifecycle](APIRef.TestLifecycle.md)
+- [Matchers](APIRef.Matchers.md)
+- [Actions](APIRef.ActionsOnElement.md)
+- [Expectations](APIRef.Expect.md)
+- [Manual Synchronization](APIRef.waitFor.md)
+- [Mocking Deep Links (App Launch From URL)](APIRef.MockingOpenFromURL.md)
+- [Mocking User Notifications](APIRef.MockingUserNotifications.md)
+- [Detox Command Line Tools (detox-cli)](APIRef.DetoxCLI.md)
+
+## Troubleshooting
+
+- [Troubleshooting Detox Installation](Troubleshooting.Installation.md)
+- [Troubleshooting a Test That Keeps Failing](Troubleshooting.RunningTests.md)
+- [Dealing With Synchronization Issues in Tests](Troubleshooting.Synchronization.md)
+- [Dealing With Flakiness in Tests](Troubleshooting.Flakiness.md)
+
+## Guides
+
+- [Running Tests Locally on Your Machine](Guide.RunningLocally.md)
+- [Developing Your App While Writing Tests](Guide.DevelopingWhileWritingTests.md)
+- [Running Tests on CI (like Travis)](Guide.RunningOnCI.md)
+- [Debugging Apps in Xcode During a Test](Guide.DebuggingInXcode.md)
+- [Advanced Mocking With Detox](Guide.Mocking.md)
+- [Migration Between Detox Versions](Guide.Migration.md)
+- [Use Jest as Test Runner](Guide.Jest.md)
+
+## Under The Hood
+
+- [Detox Design Principles](More.DesignPrinciples.md)
+
+## Contributing to Detox
+
+- [Detox Contribution Guide](Guide.Contributing.md)
+- [Detox Development Roadmap](More.Roadmap.md)
+- [Android Support - Current Status](More.AndroidSupportStatus.md)
diff --git a/website/versions.json b/website/versions.json
index d8f9140e5d..1cf1cd1125 100644
--- a/website/versions.json
+++ b/website/versions.json
@@ -1,3 +1,4 @@
 [
+  "7.X",
   "6.X"
 ]