diff --git a/projects/hip/README.md b/projects/hip/README.md
index 145f950fef..2bffd12162 100644
--- a/projects/hip/README.md
+++ b/projects/hip/README.md
@@ -6,7 +6,7 @@ Key features include:
 * HIP is very thin and has little or no performance impact over coding directly in CUDA or hcc "HC" mode.
 * HIP allows coding in a single-source C++ programming language including features such as templates, C++11 lambdas, classes, namespaces, and more.
 * HIP allows developers to use the "best" development environment and tools on each target platform.
-* The "hipify" tool automatically converts source from CUDA to HIP.
+* The [HIPIFY](hipify-clang/README.md) tools automatically convert source from CUDA to HIP.
 * Developers can specialize for the platform (CUDA or hcc) to tune for performance or handle tricky cases 
 
 New projects can be developed directly in the portable HIP C++ language and can run on either NVIDIA or AMD platforms.  Additionally, HIP provides porting tools which make it easy to port existing CUDA codes to the HIP layer, with no loss of performance as compared to the original CUDA application.  HIP is not intended to be a drop-in replacement for CUDA, and developers should expect to do some manual coding and performance tuning work to complete the port.
@@ -36,7 +36,7 @@ HIP releases are typically of two types. The tag naming convention is different
 - [HIP Profiling ](docs/markdown/hip_profiling.md)
 - [HIP Debugging](docs/markdown/hip_debugging.md)
 - [HIP Terminology](docs/markdown/hip_terms.md) (including Rosetta Stone of GPU computing terms across CUDA/HIP/HC/AMP/OpenCL)
-- [hipify-clang](hipify-clang/README.md)
+- [HIPIFY](hipify-clang/README.md)
 - Supported CUDA APIs:
   * [Runtime API](docs/markdown/CUDA_Runtime_API_functions_supported_by_HIP.md)
   * [Driver API](docs/markdown/CUDA_Driver_API_functions_supported_by_HIP.md)
@@ -71,7 +71,7 @@ hipLaunchKernel(vector_square,   /* compute kernel*/
                 dim3(blocks), dim3(threadsPerBlock), 0/*dynamic shared*/, 0/*stream*/,     /* launch config*/
                 C_d, A_d, N);  /* arguments to the compute kernel */
 
-hipMemcpy(C_h, C_d, Nbytes, hipMemcpyDeviceToHost); 
+hipMemcpy(C_h, C_d, Nbytes, hipMemcpyDeviceToHost);
 ```
 
 
@@ -88,7 +88,7 @@ __global__ void
 vector_square(T *C_d, const T *A_d, size_t N)
 {
     size_t offset = (hipBlockIdx_x * hipBlockDim_x + hipThreadIdx_x);
-    size_t stride = hipBlockDim_x * hipGridDim_x ;
+    size_t stride = hipBlockDim_x * hipGridDim_x;
 
     for (size_t i=offset; i<N; i+=stride) {
         C_d[i] = A_d[i] * A_d[i];
@@ -100,12 +100,12 @@ The HIP Runtime API code and compute kernel definition can exist in the same sou
 
 ## HIP Portability and Compiler Technology
 HIP C++ code can be compiled with either :
-- On the NVIDIA CUDA platform, HIP provides header file which translate from the HIP runtime APIs to CUDA runtime APIs.  The header file contains mostly inlined 
+- On the NVIDIA CUDA platform, HIP provides header file which translate from the HIP runtime APIs to CUDA runtime APIs.  The header file contains mostly inlined
   functions and thus has very low overhead - developers coding in HIP should expect the same performance as coding in native CUDA.  The code is then
   compiled with nvcc, the standard C++ compiler provided with the CUDA SDK.  Developers can use any tools supported by the CUDA SDK including the CUDA
   profiler and debugger.
-- On the AMD ROCm platform, HIP provides a header and runtime library built on top of hcc compiler.  The HIP runtime implements HIP streams, events, and memory APIs, 
-  and is a object library that is linked with the application.  The source code for all headers and the library implementation is available on GitHub.  
+- On the AMD ROCm platform, HIP provides a header and runtime library built on top of hcc compiler.  The HIP runtime implements HIP streams, events, and memory APIs,
+  and is a object library that is linked with the application.  The source code for all headers and the library implementation is available on GitHub.
   HIP developers on ROCm can use AMD's CodeXL for debugging and profiling.
 
 Thus HIP source code can be compiled to run on either platform.  Platform-specific features can be isolated to a specific platform using conditional compilation.  Thus HIP
@@ -114,7 +114,7 @@ provides source portability to either platform.   HIP provides the _hipcc_ compi
 
 ## Examples and Getting Started:
 
-* A sample and [blog](http://gpuopen.com/hip-to-be-squared-an-introductory-hip-tutorial) that uses hipify to convert a simple app from CUDA to HIP:
+* A sample and [blog](http://gpuopen.com/hip-to-be-squared-an-introductory-hip-tutorial) that uses any of [HIPIFY](hipify-clang/README.md) tools to convert a simple app from CUDA to HIP:
 
  
 ```shell
@@ -136,19 +136,20 @@ The GitHub repository [HIP-Examples](https://github.com/ROCm-Developer-Tools/HIP
 The README with the procedures and tips the team used during this porting effort is here: [Rodinia Porting Guide](https://github.com/ROCm-Developer-Tools/HIP-Examples/blob/master/rodinia_3.0/hip/README.hip_porting)
 
 ## Tour of the HIP Directories
-* **include**: 
+* **include**:
     * **hip_runtime_api.h** : Defines HIP runtime APIs and can be compiled with many standard Linux compilers (hcc, GCC, ICC, CLANG, etc), in either C or C++ mode.
     * **hip_runtime.h** : Includes everything in hip_runtime_api.h PLUS hipLaunchKernel and syntax for writing device kernels and device functions.  hip_runtime.h can only be compiled with hcc.
-    * **hcc_detail/**** , **nvcc_detail/**** : Implementation details for specific platforms.  HIP applications should not include these files directly.
+    * **hcc_detail/**** , **nvcc_detail/**** : Implementation details for specific platforms. HIP applications should not include these files directly.
     * **hcc.h** : Includes interop APIs for HIP and HCC
     
 * **bin**: Tools and scripts to help with hip porting
-    * **hipify** : Tool to convert CUDA code to portable CPP.  Converts CUDA APIs and kernel builtins.  
-    * **hipcc** : Compiler driver that can be used to replace nvcc in existing CUDA code. hipcc will call nvcc or hcc depending on platform, and include appropriate platform-specific headers and libraries.
-    * **hipconfig** : Print HIP configuration (HIP_PATH, HIP_PLATFORM, CXX config flags, etc)
-    * **hipexamine.sh** : Script to scan directory, find all code, and report statistics on how much can be ported with HIP (and identify likely features not yet supported)
+    * **hipify-perl** : Script based tool to convert CUDA code to portable CPP. Converts CUDA APIs and kernel builtins.
+    * **hipcc** : Compiler driver that can be used to replace nvcc in existing CUDA code. hipcc will call nvcc or hcc depending on platform and include appropriate platform-specific headers and libraries.
+    * **hipconfig** : Print HIP configuration (HIP_PATH, HIP_PLATFORM, CXX config flags, etc.)
+    * **hipexamine-perl.sh** : Script to scan the directory, find all code, and report statistics on how much can be ported with HIP (and identify likely features not yet supported).
+    * **hipconvertinplace-perl.sh** : Script to scan the directory, find all code, and convert the found CUDA code to HIP reporting all unconverted things.
 
-* **doc**: Documentation - markdown and doxygen info
+* **doc**: Documentation - markdown and doxygen info.
 
 ## Reporting an issue
 Use the [GitHub issue tracker](https://github.com/ROCm-Developer-Tools/HIP/issues).
diff --git a/projects/hip/hipify-clang/README.md b/projects/hip/hipify-clang/README.md
index c9c138e900..6607be198c 100644
--- a/projects/hip/hipify-clang/README.md
+++ b/projects/hip/hipify-clang/README.md
@@ -1,11 +1,13 @@
-# hipify-clang
-
-`hipify-clang` is a clang-based tool to translate CUDA source code into portable HIP C++ automatically.
-
+# HIPIFY
+### Tools to translate CUDA source code into portable HIP C++ automatically
 ## Table of Contents
 
 <!-- toc -->
 
+- [hipify-clang](#clang)
+     * [Usage](#hipify-clang-usage)
+- [hipify-perl](#perl)
+     * [Usage](#hipify-perl-usage)
 - [Supported CUDA APIs](#cuda-apis)
 - [Dependencies](#dependencies)
 - [Build and install](#build-and-install)
@@ -13,12 +15,92 @@
      * [Testing](#testing)
      * [Linux](#linux)
      * [Windows](#windows)
-- [Running and using hipify-clang](#running-and-using-hipify-clang)
-     * [hipify-perl](#perl)
 - [Disclaimer](#disclaimer)
 
 <!-- tocstop -->
 
+## <a name="clang"></a> hipify-clang
+
+`hipify-clang` is a clang-based tool for translation CUDA sources into HIP sources.
+It translates CUDA source into an abstract syntax tree, which is being traversed by transformation matchers.
+After applying all the matchers, the output HIP source is produced.
+
+**Advantages:**
+
+1. It is a translator; thus, any even very complicated constructs will be parsed successfully, or an error will be reported.
+2. It supports clang options like -I, -D, --cuda-path, etc.
+3. Seamless support of new CUDA versions as it is clang's responsibility.
+4. Ease in support.
+
+**Disadvantages:**
+
+1. The main advantage is also the main disadvantage: the input CUDA code should be correct; incorrect code wouldn't be translated to HIP.
+2. CUDA should be installed and provided in case of multiple installations by --cuda-path option.
+3. All the includes and defines should be provided to transform code successfully.
+
+### <a name="hipify-clang-usage"></a> hipify-clang usage
+
+To process a file, `hipify-clang` needs access to the same headers that would be required to compile it with clang.
+
+For example:
+
+```shell
+./hipify-clang square.cu --cuda-path=/usr/local/cuda-10.1 -I /usr/local/cuda-10.1/samples/common/inc
+```
+
+`hipify-clang` arguments are given first, followed by a separator '--', and then the arguments you'd pass to `clang` if you
+were compiling the input file. For example:
+
+```shell
+./hipify-clang cpp17.cu --cuda-path=/usr/local/cuda-10.1 -- -std=c++17
+```
+
+The [Clang manual for compiling CUDA](https://llvm.org/docs/CompileCudaWithLLVM.html#compiling-cuda-code) may be useful.
+
+For a list of `hipify-clang` options, run `hipify-clang --help`.
+
+## <a name="perl"></a> hipify-perl
+
+`hipify-perl` is autogenerated perl-based script which heavily uses regular expressions.
+
+**Advantages:**
+
+1. Ease in use.
+
+2. It doesn't check the input source CUDA code for correctness.
+
+3. It doesn't have dependencies on 3rd party tools, including CUDA.
+
+**Disadvantages:**
+
+1. Current disability (and difficulty in implementing) of transforming the following constructs:
+
+    * macros expansion;
+
+    * namespaces:
+
+        - redefines of CUDA entities in user namespaces;
+
+        - using directive;
+
+    * templates (some cases);
+
+    * device/host function calls distinguishing;
+
+    * header files correct injection;
+
+    * complicated argument lists parsing.
+
+2. Difficulties in supporting.
+
+### <a name="hipify-perl-usage"></a> hipify-perl usage
+
+To generate `hipify-perl`, run `hipify-clang --perl`.
+
+```shell
+perl hipify-perl square.cu > square.cu.hip
+```
+
 ## <a name="cuda-apis"></a> Supported CUDA APIs
 
 - [Runtime API](../docs/markdown/CUDA_Runtime_API_functions_supported_by_HIP.md)
@@ -391,47 +473,6 @@ cmake
 -- Generating done
 -- Build files have been written to: f:/HIP/hipify-clang/build
 ```
-
-## <a name="running-and-using-hipify-clang"></a> Running and using hipify-clang
-
-To process a file, `hipify-clang` needs access to the same headers that would be needed to compile it with clang.
-
-For example:
-
-```shell
-./hipify-clang square.cu --cuda-path=/usr/local/cuda-10.1 -I /usr/local/cuda-10.1/samples/common/inc
-```
-
-`hipify-clang` arguments are given first, followed by a separator, and then the arguments you'd pass to `clang` if you
-were compiling the input file. The [Clang manual for compiling CUDA](https://llvm.org/docs/CompileCudaWithLLVM.html#compiling-cuda-code)
-may be useful.
-
-For a list of `hipify-clang` options, run `hipify-clang --help`.
-
-### <a name="perl"></a> hipify-perl
-
-To produce a Perl-based script `hipify-perl`, run `hipify-clang --perl`.
-
-The `hipify-perl` script, unlike the `hipify-clang`, being based on regular expressions, and not on an abstract syntax tree, has several gaps:
-
-1. macros expansion;
-
-2. namespaces:
-
-    - redefines of CUDA entities in user namespaces;
-
-    - using directive;
-
-3. templates (some cases);
-
-4. device/host function calls distinguishing;
-
-5. header files correct injection;
-
-6. complicated argument lists parsing.
-
-Nonetheless, `hipify-perl` is easy in use and doesn't check the input source CUDA code for correctness.
-
 ## <a name="disclaimer"></a> Disclaimer
 
 The information contained herein is for informational purposes only, and is subject to change without notice. While every precaution has been taken in the preparation of this document, it may contain technical inaccuracies, omissions and typographical errors, and AMD is under no obligation to update or otherwise correct this information. Advanced Micro Devices, Inc. makes no representations or warranties with respect to the accuracy or completeness of the contents of this document, and assumes no liability of any kind, including the implied warranties of noninfringement, merchantability or fitness for particular purposes, with respect to the operation or use of AMD hardware, software or other products described herein. No license, including implied or arising by estoppel, to any intellectual property rights is granted by this document. Terms and limitations applicable to the purchase or use of AMD's products are as set forth in a signed agreement between the parties or in AMD's Standard Terms and Conditions of Sale.