diff --git a/DCO.html b/DCO.html
index 0eaf283..5e4eb0b 100644
--- a/DCO.html
+++ b/DCO.html
@@ -9,6 +9,8 @@
 </head>
 
 <body>
+<h1>Developer Certificate of Origin</h1>
+<p>This Developer Certificate of Origin (DCO) is a copy of version 1.1 of the DCO which originated from <a href="https://developercertificate.org/">https://developercertificate.org/</a>.</p>
 <pre>Developer Certificate of Origin
 Version 1.1
 
diff --git a/committer_process/EclipseIndividualCommitterAgreement.pdf b/committer_process/EclipseIndividualCommitterAgreement.pdf
index 12bdf53..29373d5 100644
--- a/committer_process/EclipseIndividualCommitterAgreement.pdf
+++ b/committer_process/EclipseIndividualCommitterAgreement.pdf
Binary files differ
diff --git a/committer_process/EclipseMemberCommitterAgreement.pdf b/committer_process/EclipseMemberCommitterAgreement.pdf
index 36444c9..f3ff99e 100644
--- a/committer_process/EclipseMemberCommitterAgreement.pdf
+++ b/committer_process/EclipseMemberCommitterAgreement.pdf
Binary files differ
diff --git a/content/en_index.php b/content/en_index.php
index 131769f..66a1b51 100644
--- a/content/en_index.php
+++ b/content/en_index.php
@@ -115,14 +115,17 @@
           Your privacy is important to us. This statement discloses the information practices for this web site, including what type of
           information is gathered and tracked, how the information is used, and with whom the information is shared.
         </li>
-        <li><A href="logo_guidelines.php">Trademark Usage Guidelines:</A>
+        <li><A href="logo_guidelines.php">Eclipse Foundation Trademark Usage Guidelines:</A>
           Guidelines on permissable use of Eclipse logos and trademarks.
         </li>
         <li><A href="Trademark_Transfer_Agreement.pdf">Trademark Transfer Agreement:</A>
           Pre-existing projects which move to the Eclipse Foundation will be required to execute this agreement
           to ensure that the Eclipse Foundation has rights to any trademarks associated with the project name.
         </li>
-        <li><A href="trademarkattributions.php">Trademark Attributions:</A>
+        <li><A href="trademarks.php">Eclipse Foundation Trademarks:</A>
+          The list of trademarks claimed by the Eclipse Foundation.
+        </li>
+        <li><A href="trademarks.php#attribution">Trademark Attributions:</A>
           Content on this web site may make reference to trademarks requiring attribution.
         </li>
       </ul>
diff --git a/content/en_trademarkattributions.php b/content/en_trademarkattributions.php
deleted file mode 100644
index 07383e5..0000000
--- a/content/en_trademarkattributions.php
+++ /dev/null
@@ -1,50 +0,0 @@
-<?php
-/**
- * Copyright (c) 2005, 2018 Eclipse Foundation and others.
- *
- * This program and the accompanying materials are made
- * available under the terms of the Eclipse Public License 2.0
- * which is available at https://www.eclipse.org/legal/epl-2.0/
- *
- * Contributors:
- * Denis Roy (Eclipse Foundation) - Initial implementation
- * Eric Poirier (Eclipse Foundation)
- *
- * SPDX-License-Identifier: EPL-2.0
- */
-?>
-<div id="midcolumn">
-  <h1><?php print $pageTitle; ?></h1>
-  <p>
-    14th December, 2001<br> Modified: 3 May 2016
-  </p>
-  <p>Content on this web site may make reference to the following trademarks:</p>
-  <p>Eclipse, Polarsys and Jetty are registered trademark of the Eclipse
-    Foundation, Inc. in the United States, other countries, or both.</p>
-  <p>IBM, WebSphere. DB2, MQSeries, and VisualAge are trademarks of
-    International Business Machines Corporation in the United States, other
-    countries, or both.</p>
-  <p>C-bus is a trademark of Corollary, Inc. in the United States, other
-    countries, or both.</p>
-  <p>Java and all Java-based trademarks are trademarks of Oracle Corporation in
-    the United States, other countries, or both.</p>
-  <p>Microsoft, Windows, Windows NT, and the Windows logo are trademarks of
-    Microsoft Corporation in the United States, other countries, or both.</p>
-  <p>PC Direct is a trademark of Ziff Communications Company in the United
-    States, other countries, or both and is used by IBM Corporation under
-    license.</p>
-  <p>
-    ActionMedia, LANDesk, MMX, Pentium and ProShare are trademarks of Intel
-    Corporation in the United States, other countries, or both.<br> (Click <a
-      href="http://www.intel.com/sites/corporate/tradmarx.htm"
-    >here</a> to see a complete list of Intel trademarks).
-  </p>
-  <p>UNIX is a registered trademark of The Open Group in the United States and
-    other countries.</p>
-  <p>Linux s the registered trademark of Linus Torvalds in the U.S. and other
-    countries.</p>
-  <p>Android is a trademark of Google Inc.</p>
-  <p>Other company, product, and service names may be trademarks or service
-    marks of others.</p>
-  <br />
-</div>
\ No newline at end of file
diff --git a/trademarkattributions.html b/trademarkattributions.html
index b00acae..51979c1 100644
--- a/trademarkattributions.html
+++ b/trademarkattributions.html
@@ -3,6 +3,6 @@
       <meta http-equiv="refresh" content="5; url=trademarkattributions.php" />
    </head>
    <body>
-      <a href="trademarkattributions.php">This page has moved. Please update your links and bookmarks.</a>
+      <a href="./trademarks.php#attribution">This page has moved. Please update your links and bookmarks.</a>
    </body>
 </html>
\ No newline at end of file
diff --git a/trademarkattributions.php b/trademarkattributions.php
index 346a80d..dae10f2 100644
--- a/trademarkattributions.php
+++ b/trademarkattributions.php
@@ -1,33 +1,11 @@
 <?php
 /**
- * Copyright (c) 2005, 2018 Eclipse Foundation and others.
+ * Copyright (c) 2021 Eclipse Foundation and others.
  *
  * This program and the accompanying materials are made
  * available under the terms of the Eclipse Public License 2.0
  * which is available at https://www.eclipse.org/legal/epl-2.0/
  *
- * Contributors:
- * Denis Roy (Eclipse Foundation) - Initial implementation
- * Eric Poirier (Eclipse Foundation)
- *
  * SPDX-License-Identifier: EPL-2.0
  */
-require_once ($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");
-
-$App = new App();
-$Theme = $App->getThemeClass();
-
-include ($App->getProjectCommon());
-
-$pageTitle = "Trademark Attributions";
-$Theme->setPageTitle($pageTitle);
-$Theme->setPageKeywords("legal, trademarks");
-$Theme->setPageAuthor("Mike Milinkovich, Nov. 22, 2005");
-
-ob_start();
-include ("content/en_" . $App->getScriptName());
-$html = ob_get_clean();
-
-$Theme->setHtml($html);
-$Theme->setNav($Nav);
-$Theme->generatePage();
\ No newline at end of file
+header('Location: ./trademarks.php#attribution');
\ No newline at end of file
diff --git a/trademarks.php b/trademarks.php
index 6ff1df0..024973b 100644
--- a/trademarks.php
+++ b/trademarks.php
@@ -1,2 +1,123 @@
+<?php
+/*******************************************************************************
+ * Copyright (c) 2018, 2021 Eclipse Foundation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *******************************************************************************/
+
+require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");
+require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php");
+require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php");
+require_once($_SERVER['DOCUMENT_ROOT'] . "/projects/classes/database.inc");
+require_once($_SERVER['DOCUMENT_ROOT'] . "/projects/classes/common.php");
+
+$App = new App();
+$Nav = new Nav();
+$Menu = new Menu();
+include($App->getProjectCommon());
+
+$pageTitle 		= "Eclipse Foundation Trademarks";
+$pageKeywords	= "";
+$pageAuthor		= "Wayne Beaton";
+
+ob_start();
+
+function displayTrademarks($sql) {
+    echo "<ul>";
+    query('dashboard', $sql, array(), function($row) {
+        $mark = $row['type'] == 'R' ? '&reg' : '&trade;';
+        echo "<li>{$row['name']}{$mark}</li>";
+    });
+    echo "</ul>";
+}
+
+?>
+<div id="maincontent">
+<div id="midcolumn">
+<h1><?= $pageTitle ?></h1>
+
+<p>The names and logos of all open source
+	projects, working groups, specifications, and all downloadable
+	software products, are trademarks of the the Eclipse Foundation. In
+	addition the Eclipse Foundation logo is a trademark of the Eclipse
+	Foundation.</p>
+
+<p>This document captures a list of trademarks claimed by the Eclipse Foundation.</p>
+
+<h2 id="use">Trademark Use</h2>
+
+<p>The <a href="/legal/logo_guidelines.php">Eclipse Foundation Trademark Usage Guidelines</a>
+defines the allowable use of Eclipse Foundation names, marks and logos.</p>
+
+<p>Supplemental guidelines:</p>
+
+<ul>
+<li><a href="https://jakarta.ee/legal/trademark_guidelines/">Jakarta EE Trademark Guidelines</a></li>
+</ul>
+
+<h2 id="attribution">Trademark Disclaimers</h2>
+
+<p>Content on this web site, including the names listed on this page, may
+    make reference to the trademarks in the following list. We disclaim any
+    claim to trademark rights in their usage.</p>
+
+<ul>
+	<li>Java and all Java-based trademarks are trademarks of Oracle
+		Corporation in the United States, other countries, or both.</li>
+	<li>Microsoft, Windows, Windows NT, and the Windows logo are
+		trademarks of Microsoft Corporation in the United States, other
+		countries, or both.</li>
+	<li>UNIX is a registered trademark of The Open Group in the United
+		States and other countries.</li>
+	<li>Linux is the registered trademark of Linus Torvalds in the U.S.
+		and other countries.</li>
+	<li>Android is a trademark of Google Inc.</li>
+	<li>Other company, product, and service names may be trademarks or
+		service marks of others.</li>
+</ul>
+
+<h2 id="registered">Registered Trademarks</h2>
+
 <?php 
-include "../projects/tools/trademarks.php";
\ No newline at end of file
+$sql = "select distinct name, type from Trademark where type='R' order by name";
+displayTrademarks($sql);
+?>
+
+<h3 id="other">Other Trademarks</h3>
+
+<?php 
+$sql = "select distinct name, type from Trademark where category in ('other' ,'simrel') and type != 'R' order by name";
+displayTrademarks($sql);
+?>
+
+<h2 id="wg">Eclipse Foundation Working Groups</h2>
+
+<?php 
+$sql = "select distinct name, type from Trademark where category='wg' order by name";
+displayTrademarks($sql);
+?>
+
+<h2 id="specifications">Eclipse Foundation Specifications</h2>
+
+<?php 
+$sql = "select name, type from Trademark where category='specification' order by name";
+displayTrademarks($sql);
+?>
+
+<h2 id="projects">Eclipse Foundation Projects</h2>
+
+<?php 
+$sql = "select name, type from Trademark where category='project' order by name";
+displayTrademarks($sql);
+?>
+
+</div>
+</div>
+
+<?php
+$html = ob_get_contents();
+ob_end_clean();
+$App->generatePage(null, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
+?>
\ No newline at end of file
