diff --git a/community.html b/community.html
index ec78c38..6de27e0 100755
--- a/community.html
+++ b/community.html
@@ -7,12 +7,24 @@
 	<meta name="description" content="EMF Compare provides comparison and merge facility for any kind of EMF Model">
 	 
 	<script src="//ajax.googleapis.com/ajax/libs/jquery/1.8.1/jquery.min.js"></script>
-	<script type="text/javascript" src="js/googleAnalytics.js"></script>
 	<script type="text/javascript" src="js/functions.js"></script>
 	
 	<link rel="icon" type="image/png" href="favicon.ico" />
 	<title>EMF Compare - Compare and Merge Your EMF Models</title>
-	<link type="text/css" rel="stylesheet" href="css/style.css" />		
+	<link type="text/css" rel="stylesheet" href="css/style.css" />
+	
+	<!-- Eclipse Foundation Google Tag Manager -->
+    <script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
+    new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
+    j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
+    'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
+    })(window,document,'script','dataLayer','GTM-5WLCZXC');</script>
+    <!-- End Google Tag Manager --> 
+   
+    <!-- Eclipse Foundation cookie consent: -->
+    <link rel="stylesheet" type="text/css" href="//www.eclipse.org/eclipse.org-common/themes/solstice/public/stylesheets/vendor/cookieconsent/cookieconsent.min.css" />
+    <script src="//www.eclipse.org/eclipse.org-common/themes/solstice/public/javascript/vendor/cookieconsent/default.min.js"></script>
+	<!-- End Eclipse Foundation cookie consent: -->
 </head>
 	
 <body>
diff --git a/css/style.css b/css/style.css
index 33d3e86..0db18d5 100755
--- a/css/style.css
+++ b/css/style.css
@@ -785,4 +785,25 @@
 
 #footer_wrapper .column.right {
 	width: 184px;
+}
+
+/* Eclipse Cookies Consent
+-------------------------- */
+
+.cc-color-override-1434350510.cc-window, .cc-color-override-1434350510.cc-revoke, .cc-color-override-1434350510 .cc-btn {
+    font-family: "Open Sans Condensed", Arial, sans-serif !important;
+    }
+
+.cc-color-override-1434350510.cc-window, .cc-color-override-1434350510.cc-revoke {
+background-color: #1e2786 !important;
+}
+.cc-color-override-1434350510 .cc-btn:last-child {
+background-color: #c06cea !important;}
+
+.cc-color-override-1434350510 .cc-btn:hover, .cc-color-override-1434350510 .cc-btn:focus {
+    background-color: #6a95ea !important;
+}
+
+.cc-banner .cc-message {
+    padding-right: 50px;
 }
\ No newline at end of file
diff --git a/download.html b/download.html
index 8440cea..029846e 100755
--- a/download.html
+++ b/download.html
@@ -7,12 +7,24 @@
 	<meta name="description" content="EMF Compare provides comparison and merge facility for any kind of EMF Model.">
 	 
 	<script src="//ajax.googleapis.com/ajax/libs/jquery/1.8.1/jquery.min.js"></script>
-	<script type="text/javascript" src="js/googleAnalytics.js"></script>
 	<script type="text/javascript" src="js/functions.js"></script>
 	
 	<link rel="icon" type="image/png" href="favicon.ico" />
 	<title>EMF Compare - Compare and Merge Your EMF Models</title>
 	<link type="text/css" rel="stylesheet" href="css/style.css" />	
+	
+	<!-- Eclipse Foundation Google Tag Manager -->
+    <script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
+    new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
+    j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
+    'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
+    })(window,document,'script','dataLayer','GTM-5WLCZXC');</script>
+    <!-- End Google Tag Manager --> 
+   
+    <!-- Eclipse Foundation cookie consent: -->
+    <link rel="stylesheet" type="text/css" href="//www.eclipse.org/eclipse.org-common/themes/solstice/public/stylesheets/vendor/cookieconsent/cookieconsent.min.css" />
+    <script src="//www.eclipse.org/eclipse.org-common/themes/solstice/public/javascript/vendor/cookieconsent/default.min.js"></script>
+	<!-- End Eclipse Foundation cookie consent: -->
 </head>
 	
 <body>
diff --git a/index.html b/index.html
index 32a31d7..c07dbf1 100755
--- a/index.html
+++ b/index.html
@@ -7,14 +7,26 @@
 	<meta name="description" content="EMF Compare provides comparison and merge facility for any kind of EMF Model">
 	 
 	<script src="//ajax.googleapis.com/ajax/libs/jquery/1.8.1/jquery.min.js"></script>
-	<script type="text/javascript" src="js/googleAnalytics.js"></script>
 	<script type="text/javascript" src="js/magnific-popup.video.js"></script> 
 	<script type="text/javascript" src="js/magnific-popup.min.js"></script>
 	<script type="text/javascript" src="js/functions.js"></script>		 
 	<link rel="icon" type="image/png" href="favicon.ico" />
 	<title>EMF Compare - Compare and Merge Your EMF Models</title>
 	<link type="text/css" rel="stylesheet" href="css/style.css" />
-	<link type="text/css" rel="stylesheet" href="css/media.css" />			
+	<link type="text/css" rel="stylesheet" href="css/media.css" />
+	
+	<!-- Eclipse Foundation Google Tag Manager -->
+    <script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
+    new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
+    j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
+    'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
+    })(window,document,'script','dataLayer','GTM-5WLCZXC');</script>
+    <!-- End Google Tag Manager --> 
+   
+    <!-- Eclipse Foundation cookie consent: -->
+    <link rel="stylesheet" type="text/css" href="//www.eclipse.org/eclipse.org-common/themes/solstice/public/stylesheets/vendor/cookieconsent/cookieconsent.min.css" />
+    <script src="//www.eclipse.org/eclipse.org-common/themes/solstice/public/javascript/vendor/cookieconsent/default.min.js"></script>
+	<!-- End Eclipse Foundation cookie consent: -->
 </head>
 	
 <body>
diff --git a/js/googleAnalytics.js b/js/googleAnalytics.js
deleted file mode 100755
index 052fe62..0000000
--- a/js/googleAnalytics.js
+++ /dev/null
@@ -1,13 +0,0 @@
-(function(i, s, o, g, r, a, m) {
-	i['GoogleAnalyticsObject'] = r;
-	i[r] = i[r] || function() {
-		(i[r].q = i[r].q || []).push(arguments)
-	}, i[r].l = 1 * new Date();
-	a = s.createElement(o), m = s.getElementsByTagName(o)[0];
-	a.async = 1;
-	a.src = g;
-	m.parentNode.insertBefore(a, m)
-})(window, document, 'script', '//www.google-analytics.com/analytics.js', 'ga');
-
-ga('create', 'UA-48457939-1', 'eclipse.org');
-ga('send', 'pageview');
diff --git a/overview.html b/overview.html
index 392abff..94ccc3b 100755
--- a/overview.html
+++ b/overview.html
@@ -7,7 +7,6 @@
 	<meta name="description" content="EMF Compare provides comparison and merge facility for any kind of EMF Model">
 	 
 	<script src="//ajax.googleapis.com/ajax/libs/jquery/1.8.1/jquery.min.js"></script>
-	<script type="text/javascript" src="js/googleAnalytics.js"></script>
 	<script type="text/javascript" src="js/magnific-popup.video.js"></script> 
 	<script type="text/javascript" src="js/magnific-popup.min.js"></script>
 	<script type="text/javascript" src="js/functions.js"></script>
@@ -15,6 +14,19 @@
 	<title>EMF Compare - Compare and Merge Your EMF Models</title>
 	<link type="text/css" rel="stylesheet" href="css/style.css" />		
 	<link type="text/css" rel="stylesheet" href="css/media.css" />
+	
+	<!-- Eclipse Foundation Google Tag Manager -->
+    <script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
+    new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
+    j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
+    'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
+    })(window,document,'script','dataLayer','GTM-5WLCZXC');</script>
+    <!-- End Google Tag Manager --> 
+   
+    <!-- Eclipse Foundation cookie consent: -->
+    <link rel="stylesheet" type="text/css" href="//www.eclipse.org/eclipse.org-common/themes/solstice/public/stylesheets/vendor/cookieconsent/cookieconsent.min.css" />
+    <script src="//www.eclipse.org/eclipse.org-common/themes/solstice/public/javascript/vendor/cookieconsent/default.min.js"></script>
+	<!-- End Eclipse Foundation cookie consent: -->
 </head>
 	
 <body>
