diff --git a/INSTALL.md b/INSTALL.md
index 2a2e406948..74df7372a9 100644
--- a/INSTALL.md
+++ b/INSTALL.md
@@ -4,14 +4,13 @@
 
 - [Installing pre-built packages](#installing-pre-built-packages)
   * [Prerequisites](#prerequisites)
-  * [HIP-hcc](#hip-hcc)
-  * [HIP-clang](#hip-clang)
-  * [HIP-nvcc](#hip-nvcc)
-  * [Verify your installation](#verify-your-installation)
+  * [AMD Platform](#amd-platform)
+  * [NVIDIA Platform](#nvidia-platform)
 - [Building HIP from source](#building-hip-from-source)
-  * [HCC Options](#hcc-options)
-    + [Using HIP with the AMD Native-GCN compiler.](#using-hip-with-the-amd-native-gcn-compiler)
-
+  * [Build ROCclr](#build-rocclr)
+  * [Build HIP](#build-hip)
+  * [Default paths and environment variables](#default-paths-and-environment-variables)
+- [Verify your installation](#verify-your-installation)
 <!-- tocstop -->
 
 # Installing pre-built packages
@@ -19,72 +18,46 @@
 HIP can be easily installed using pre-built binary packages using the package manager for your platform.
 
 ## Prerequisites
-HIP code can be developed either on AMD ROCm platform using hcc or clang compiler, or a CUDA platform with nvcc installed:
+HIP code can be developed either on AMD ROCm platform using HIP-Clang compiler, or a CUDA platform with nvcc installed.
 
-## HIP-hcc
-
-* Add the ROCm package server to your system as per the OS-specific guide available [here](https://rocm.github.io/ROCmInstall.html#installing-from-amd-rocm-repositories).
-* Install the "hip-hcc" package. This will install HCC and the HIP porting layer.
-```
-apt-get install hip-hcc
-```
-
-* Default paths and environment variables:
-
-   * By default HIP looks for hcc in /opt/rocm/hcc (can be overridden by setting HCC_HOME environment variable)
-   * By default HIP looks for HSA in /opt/rocm/hsa (can be overridden by setting HSA_PATH environment variable) 
-   * By default HIP is installed into /opt/rocm/hip (can be overridden by setting HIP_PATH environment variable).
-   * Optionally, consider adding /opt/rocm/bin to your PATH to make it easier to use the tools.
-
-## HIP-clang
-
-* Using clang to compile HIP program for AMD GPU is under development. Users need to build LLVM, clang, lld, ROCm device library, and HIP from source.
-
-* Install the [rocm](http://gpuopen.com/getting-started-with-boltzmann-components-platforms-installation/) packages.  ROCm will install some of the necessary components, including the kernel driver, HSA runtime, etc.
-
-* Build HIP-Clang
+## AMD Platform
 
 ```
-git clone https://github.com/llvm/llvm-project.git
+sudo apt install mesa-common-dev
+sudo apt install clang
+sudo apt install comgr
+sudo apt-get -y install rocm-dkms
+```
+Public link for Rocm installation
+https://rocmdocs.amd.com/en/latest/Installation_Guide/Installation-Guide.html
+
+HIP-Clang is the compiler for compiling HIP programs on AMD platform.
+
+HIP-Clang can be built manually:
+```
+git clone -b rocm-3.10.x https://github.com/RadeonOpenCompute/llvm-project.git
+cd llvm-project
 mkdir -p build && cd build
-cmake -DCMAKE_INSTALL_PREFIX=/opt/rocm/llvm -DCMAKE_BUILD_TYPE=Release -DLLVM_ENABLE_ASSERTIONS=1 -DLLVM_TARGETS_TO_BUILD="AMDGPU;X86" -DLLVM_EXTERNAL_LLD_SOURCE_DIR=../lld -DLLVM_EXTERNAL_CLANG_SOURCE_DIR=../clang ../llvm
+cmake -DCMAKE_INSTALL_PREFIX=/opt/rocm/llvm -DCMAKE_BUILD_TYPE=Release -DLLVM_ENABLE_ASSERTIONS=1 -DLLVM_TARGETS_TO_BUILD="AMDGPU;X86" -DLLVM_ENABLE_PROJECTS="clang;lld;compiler-rt" ../llvm
 make -j
 sudo make install
 ```
 
-* Build Rocm device library
-
+Rocm device library can be manually built as following,
 ```
 export PATH=/opt/rocm/llvm/bin:$PATH
-git clone -b amd-stg-open https://github.com/RadeonOpenCompute/ROCm-Device-Libs.git
+git clone -b rocm-3.10.x https://github.com/RadeonOpenCompute/ROCm-Device-Libs.git
 cd ROCm-Device-Libs
 mkdir -p build && cd build
-CC=clang CXX=clang++ cmake -DLLVM_DIR=/opt/rocm/llvm -DCMAKE_BUILD_TYPE=Release -DLLVM_ENABLE_WERROR=1 -DLLVM_ENABLE_ASSERTIONS=1 ..
+CC=clang CXX=clang++ cmake -DLLVM_DIR=/opt/rocm/llvm -DCMAKE_BUILD_TYPE=Release -DLLVM_ENABLE_WERROR=1 -DLLVM_ENABLE_ASSERTIONS=1 -DCMAKE_INSTALL_PREFIX=/opt/rocm ..
 make -j
 sudo make install
 ```
 
-* Build HIP
+## NVIDIA Platform
 
-```
-git clone -b master https://github.com/ROCm-Developer-Tools/HIP.git
-cd HIP
-mkdir -p build && cd build
-cmake -DCMAKE_INSTALL_PREFIX=/opt/rocm/hip -DHIP_COMPILER=clang -DCMAKE_BUILD_TYPE=Release ..
-make -j
-sudo make install
-```
+HIP-nvcc is the compiler for HIP program compilation on NVIDIA platform.
 
-* Default paths and environment variables:
-
-   * By default HIP looks for HSA in /opt/rocm/hsa (can be overridden by setting HSA_PATH environment variable) 
-   * By default HIP is installed into /opt/rocm/hip (can be overridden by setting HIP_PATH environment variable).
-   * By default HIP looks for clang in /opt/rocm/llvm/bin (can be overridden by setting HIP_CLANG_PATH environment variable)
-   * By default HIP looks for device library in /opt/rocm/lib (can be overriden by setting DEVICE_LIB_PATH environment variable).
-   * Optionally, consider adding /opt/rocm/bin to your PATH to make it easier to use the tools.
-   * Optionally, set HIPCC_VERBOSE=7 to output the command line for compilation to make sure clang is used instead of hcc.
-
-## HIP-nvcc
 * Add the ROCm package server to your system as per the OS-specific guide available [here](https://rocm.github.io/ROCmInstall.html#installing-from-amd-rocm-repositories).
 * Install the "hip-nvcc" package.  This will install CUDA SDK and the HIP porting layer.
 ```
@@ -92,54 +65,59 @@ apt-get install hip-nvcc
 ```
 
 * Default paths and environment variables:
-   * By default HIP looks for CUDA SDK in /usr/local/cuda (can be overriden by setting CUDA_PATH env variable)
+   * By default HIP looks for CUDA SDK in /usr/local/cuda (can be overriden by setting CUDA_PATH env variable).
    * By default HIP is installed into /opt/rocm/hip (can be overridden by setting HIP_PATH environment variable).
    * Optionally, consider adding /opt/rocm/bin to your path to make it easier to use the tools.
 
+# Building HIP from source
+
+## Build ROCclr
+
+ROCclr is defined on AMD platform that HIP use Radeon Open Compute Common Language Runtime (ROCclr), which is a virtual device interface that HIP runtimes interact with different backends.
+See https://github.com/ROCm-Developer-Tools/ROCclr
+
+```
+git clone -b rocm-3.10.x https://github.com/ROCm-Developer-Tools/ROCclr.git
+export ROCclr_DIR="$(readlink -f ROCclr)"
+git clone -b rocm-3.10.x https://github.com/RadeonOpenCompute/ROCm-OpenCL-Runtime.git
+export OPENCL_DIR="$(readlink -f ROCm-OpenCL-Runtime)"
+cd "$ROCclr_DIR"
+mkdir -p build;cd build
+cmake -DOPENCL_DIR="$OPENCL_DIR" -DCMAKE_INSTALL_PREFIX=/opt/rocm/rocclr ..
+make -j
+sudo make install
+```
+
+## Build HIP
+
+```
+git clone -b rocm-3.10.x https://github.com/ROCm-Developer-Tools/HIP.git
+export HIP_DIR="$(readlink -f HIP)"
+cd "$HIP_DIR"
+mkdir -p build; cd build
+cmake -DCMAKE_BUILD_TYPE=Release -DHIP_COMPILER=clang -DHIP_PLATFORM=rocclr -DCMAKE_PREFIX_PATH="$ROCclr_DIR/build;/opt/rocm/" -DCMAKE_INSTALL_PREFIX=</where/to/install/hip> ..
+make -j
+sudo make install
+```
+
+## Default paths and environment variables
+
+   * By default HIP looks for HSA in /opt/rocm/hsa (can be overridden by setting HSA_PATH environment variable).
+   * By default HIP is installed into /opt/rocm/hip (can be overridden by setting HIP_PATH environment variable).
+   * By default HIP looks for clang in /opt/rocm/llvm/bin (can be overridden by setting HIP_CLANG_PATH environment variable)
+   * By default HIP looks for device library in /opt/rocm/lib (can be overridden by setting DEVICE_LIB_PATH environment variable).
+   * Optionally, consider adding /opt/rocm/bin to your PATH to make it easier to use the tools.
+   * Optionally, set HIPCC_VERBOSE=7 to output the command line for compilation.
+
+After installation, make sure HIP_PATH is pointed to /where/to/install/hip
+
+# Verify your installation
 
-## Verify your installation
 Run hipconfig (instructions below assume default installation path) :
 ```shell
 /opt/rocm/bin/hipconfig --full
 ```
 
-Compile and run the [square sample](https://github.com/ROCm-Developer-Tools/HIP/tree/master/samples/0_Intro/square). 
 
-
-# Building HIP from source
-HIP source code is available and the project can be built from source on the HCC platform. 
-
-1. Follow the above steps to install and validate the binary packages.
-2. Download HIP source code (from the [GitHub repot](https://github.com/ROCm-Developer-Tools/HIP).)
-3. Install HIP build-time dependencies using ```sudo apt-get install libelf-dev```.
-4. Build and install HIP (This is the simple version assuming default paths ; see below for additional options.)
-
-By default, HIP uses HCC to compile programs. To use HIP-Clang, add -DHIP_COMPILER=clang to cmake command line.
-
-```
-cd HIP
-mkdir build
-cd build
-cmake .. 
-make
-make install
-```
-
-* Default paths:
-  * By default cmake looks for hcc in /opt/rocm/hcc (can be overridden by setting ```-DHCC_HOME=/path/to/hcc``` in the cmake step).*
-  * By default cmake looks for HSA in /opt/rocm/hsa (can be overridden by setting ```-DHSA_PATH=/path/to/hsa``` in the cmake step).*
-  * By default cmake installs HIP to /opt/rocm/hip (can be overridden by setting ```-DCMAKE_INSTALL_PREFIX=/where/to/install/hip``` in the cmake step).*
-
-Here's a richer command-line that overrides the default paths:
-
-```shell
-cd HIP
-mkdir build
-cd build
-cmake -DHSA_PATH=/path/to/hsa -DHCC_HOME=/path/to/hcc -DCMAKE_INSTALL_PREFIX=/where/to/install/hip -DCMAKE_BUILD_TYPE=Release ..
-make
-make install
-```
-
-* After installation, make sure HIP_PATH is pointed to `/where/to/install/hip`. 
+Compile and run the [square sample](https://github.com/ROCm-Developer-Tools/HIP/tree/master/samples/0_Intro/square).
 
diff --git a/README.md b/README.md
index f9880bded6..16b6f89338 100644
--- a/README.md
+++ b/README.md
@@ -16,15 +16,15 @@ New projects can be developed directly in the portable HIP C++ language and can
 
 The HIP repository maintains several branches. The branches that are of importance are:
 
-* master branch: This is the stable branch. All stable releases are based on this branch.
-* developer-preview branch: This is the branch were the new features still under development are visible. While this maybe of interest to many, it should be noted that this branch and the features under development might not be stable.
+* Main branch: This is the stable branch. It is up to date with the latest release branch, for example, if the latest HIP release is rocm-3.9, main branch will be the repository based on this release.
+* Release branches. These are branches corresponding to each ROCM release, listed with release tags, such as rocm-3.8, rocm-3.9, etc.
 
 ## Release tagging:
 
-HIP releases are typically of two types. The tag naming convention is different for both types of releases to help differentiate them.
+HIP releases are typically naming convention for each ROCM release to help differentiate them.
 
-* release_x.yy.zzzz: These are the stable releases based on the master branch. This type of release is typically made once a month.
-* preview_x.yy.zzzz: These denote pre-release code and are based on the developer-preview branch. This type of release is typically made once a week.
+* rocm x.yy: These are the stable releases based on the ROCM release. 
+  This type of release is typically made once a month.*
 
 ## More Info:
 - [Installation](INSTALL.md)