diff --git a/samples/dynatable/src/com/google/gwt/sample/dynatable/public/DynaTable.html b/samples/dynatable/src/com/google/gwt/sample/dynatable/public/DynaTable.html
index aaef3f0..e3cc2c5 100644
--- a/samples/dynatable/src/com/google/gwt/sample/dynatable/public/DynaTable.html
+++ b/samples/dynatable/src/com/google/gwt/sample/dynatable/public/DynaTable.html
@@ -1,8 +1,24 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+ "http://www.w3.org/TR/html4/loose.dtd">
+ 
+<!--                                                                        -->
+<!-- Copyright 2008 Google Inc.                                             -->
+<!-- Licensed under the Apache License, Version 2.0 (the "License"); you    -->
+<!-- may not use this file except in compliance with the License. You may   -->
+<!-- may obtain a copy of the License at                                    -->
+<!--                                                                        -->
+<!-- http://www.apache.org/licenses/LICENSE-2.0                             -->
+<!--                                                                        -->
+<!-- Unless required by applicable law or agreed to in writing, software    -->
+<!-- distributed under the License is distributed on an "AS IS" BASIS,      -->
+<!-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        -->
+<!-- implied. License for the specific language governing permissions and   -->
+<!-- limitations under the License.                                         -->
+ 
+<html>
   <head>
-    <link type="text/css" rel="stylesheet" href="DynaTable.css" />
+    <meta http-equiv="content-type" content="text/html; charset=UTF-8">
+    <link type="text/css" rel="stylesheet" href="DynaTable.css">
     <title></title>
   </head>
   <body>
diff --git a/samples/hello/src/com/google/gwt/sample/hello/public/Hello.html b/samples/hello/src/com/google/gwt/sample/hello/public/Hello.html
index 1dc9a6f..245fbf1 100644
--- a/samples/hello/src/com/google/gwt/sample/hello/public/Hello.html
+++ b/samples/hello/src/com/google/gwt/sample/hello/public/Hello.html
@@ -1,8 +1,26 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+ "http://www.w3.org/TR/html4/loose.dtd">
+ 
+<!--                                                                        -->
+<!-- Copyright 2008 Google Inc.                                             -->
+<!-- Licensed under the Apache License, Version 2.0 (the "License"); you    -->
+<!-- may not use this file except in compliance with the License. You may   -->
+<!-- may obtain a copy of the License at                                    -->
+<!--                                                                        -->
+<!-- http://www.apache.org/licenses/LICENSE-2.0                             -->
+<!--                                                                        -->
+<!-- Unless required by applicable law or agreed to in writing, software    -->
+<!-- distributed under the License is distributed on an "AS IS" BASIS,      -->
+<!-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        -->
+<!-- implied. License for the specific language governing permissions and   -->
+<!-- limitations under the License.                                         -->
+ 
 <html>
-	<head>
-		<title>Hello</title>
-	</head>
-	<body bgcolor="white"> 
-		<script language="javascript" src="com.google.gwt.sample.hello.Hello.nocache.js"></script>
-	</body>
+  <head>
+    <meta http-equiv="content-type" content="text/html; charset=UTF-8">
+    <title>Hello</title>
+  </head>
+  <body bgcolor="white"> 
+    <script type="text/javascript" language="javascript" src="com.google.gwt.sample.hello.Hello.nocache.js"></script>
+  </body>
 </html>
diff --git a/samples/i18n/src/com/google/gwt/sample/i18n/public/I18N.html b/samples/i18n/src/com/google/gwt/sample/i18n/public/I18N.html
index 97f908b..37b91e2 100644
--- a/samples/i18n/src/com/google/gwt/sample/i18n/public/I18N.html
+++ b/samples/i18n/src/com/google/gwt/sample/i18n/public/I18N.html
@@ -1,5 +1,8 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+ "http://www.w3.org/TR/html4/loose.dtd">
+
 <!--                                                                        -->
-<!-- Copyright 2007 Google Inc.                                             -->
+<!-- Copyright 2008 Google Inc.                                             -->
 <!-- Licensed under the Apache License, Version 2.0 (the "License"); you    -->
 <!-- may not use this file except in compliance with the License. You may   -->
 <!-- may obtain a copy of the License at                                    -->
@@ -13,8 +16,10 @@
 <!-- limitations under the License.                                         -->
 
 <html>
-<head>
-<script language=javascript>
+<head> 
+   <meta http-equiv="content-type" content="text/html; charset=UTF-8">
+
+<script type="text/javascript" language="javascript">
   // Used by the dictionary example. 
   // If you modify this object, the example will reflect your changes.
   var userInfo = {
@@ -29,11 +34,11 @@
 <!-- if the locale is not present in the URL query string.-->
 <!-- <meta name='gwt:property' content='locale=fr'>-->
 
-<link rel="stylesheet" type="text/css" href="I18N.css" />
+<link rel="stylesheet" type="text/css" href="I18N.css">
 
 <title>Internationalization Sample</title>
 
-<script language="javascript"
+<script type="text/javascript" language="javascript"
   src="com.google.gwt.sample.i18n.I18N.nocache.js"></script>
 
 </head>
@@ -115,7 +120,7 @@
           <th class="col1">&nbsp;</th>
           <td class="col2" id="dateTimeFormatPatternText"></td>
           <td class="col3" id="dateTimeFormatPatternError">&nbsp;</td>
-        </div>
+        </tr>
       
         <tr>
           <th class="col1" id="dateTimeFormatInputCaption"></th>
diff --git a/samples/json/src/com/google/gwt/sample/json/public/JSON.html b/samples/json/src/com/google/gwt/sample/json/public/JSON.html
index 903eeb7..ebb3bf2 100644
--- a/samples/json/src/com/google/gwt/sample/json/public/JSON.html
+++ b/samples/json/src/com/google/gwt/sample/json/public/JSON.html
@@ -1,10 +1,29 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+ "http://www.w3.org/TR/html4/loose.dtd">
+ 
+<!--                                                                        -->
+<!-- Copyright 2008 Google Inc.                                             -->
+<!-- Licensed under the Apache License, Version 2.0 (the "License"); you    -->
+<!-- may not use this file except in compliance with the License. You may   -->
+<!-- may obtain a copy of the License at                                    -->
+<!--                                                                        -->
+<!-- http://www.apache.org/licenses/LICENSE-2.0                             -->
+<!--                                                                        -->
+<!-- Unless required by applicable law or agreed to in writing, software    -->
+<!-- distributed under the License is distributed on an "AS IS" BASIS,      -->
+<!-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        -->
+<!-- implied. License for the specific language governing permissions and   -->
+<!-- limitations under the License.                                         -->
+ 
 <html>
 	<head>
-		<link rel='stylesheet' href='JSON.css'>
+		<meta http-equiv="content-type" content="text/html; charset=UTF-8">
+                <link type="text/css" rel='stylesheet' href='JSON.css'>
 		<title>JSON Interoperability Example</title>
 	</head>
 	<body>
-		<script language='javascript' src='com.google.gwt.sample.json.JSON.nocache.js'></script>
+		<script type="text/javascript" language='javascript' 
+                        src='com.google.gwt.sample.json.JSON.nocache.js'></script>
 		
 		<h1>JSON Interop Using JSNI</h1>
 		
@@ -20,16 +39,17 @@
 			When you click the "Search" button below, you can browse the cached 
 			results of a Yahoo JSON image search for "potato."  The response is 
 			parsed into Java objects which are used to populate a tree view below.
+			</p>
+
 			<ul>
 				<li>For more details on how the JSON response is parsed into a set 
 				    of Java objects, see the JSONParser class.
 				<li>The search URL used in this example was 
-					<a href='http://api.search.yahoo.com/ImageSearchService/V1/imageSearch?appid=YahooDemo&query=potato&results=2&output=json'>http://api.search.yahoo.com/ImageSearchService/V1/imageSearch?appid=YahooDemo&query=potato&results=2&output=json</a>.
+					<a href='http://api.search.yahoo.com/ImageSearchService/V1/imageSearch?appid=YahooDemo&amp;query=potato&amp;results=2&amp;output=json'>http://api.search.yahoo.com/ImageSearchService/V1/imageSearch?appid=YahooDemo&amp;query=potato&amp;results=2&amp;output=json</a>.
 			</ul>
-			</p>
 			
-			<p id="search">
-			</p>
+			<div id="search">
+			</div>
 		</div>
 
 		<table align="center" width="80%" style="margin-top: 1em">
diff --git a/samples/kitchensink/src/com/google/gwt/sample/kitchensink/public/KitchenSink.html b/samples/kitchensink/src/com/google/gwt/sample/kitchensink/public/KitchenSink.html
index 8f745d3..d5d3ef5 100644
--- a/samples/kitchensink/src/com/google/gwt/sample/kitchensink/public/KitchenSink.html
+++ b/samples/kitchensink/src/com/google/gwt/sample/kitchensink/public/KitchenSink.html
@@ -1,9 +1,27 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+ "http://www.w3.org/TR/html4/loose.dtd">
+ 
+<!--                                                                        -->
+<!-- Copyright 2008 Google Inc.                                             -->
+<!-- Licensed under the Apache License, Version 2.0 (the "License"); you    -->
+<!-- may not use this file except in compliance with the License. You may   -->
+<!-- may obtain a copy of the License at                                    -->
+<!--                                                                        -->
+<!-- http://www.apache.org/licenses/LICENSE-2.0                             -->
+<!--                                                                        -->
+<!-- Unless required by applicable law or agreed to in writing, software    -->
+<!-- distributed under the License is distributed on an "AS IS" BASIS,      -->
+<!-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        -->
+<!-- implied. License for the specific language governing permissions and   -->
+<!-- limitations under the License.                                         -->
+ 
 <html>
 	<head>
+	  <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 		<title>Kitchen Sink</title>
 	</head>
 	<body>
-		<script language='javascript' src='com.google.gwt.sample.kitchensink.KitchenSink.nocache.js'></script>
+		<script type="text/javascript" language='javascript' src='com.google.gwt.sample.kitchensink.KitchenSink.nocache.js'></script>
 		<iframe src="javascript:''" id='__gwt_historyFrame' style='width:0;height:0;border:0'></iframe>
 	</body>
 </html>
diff --git a/samples/mail/src/com/google/gwt/sample/mail/public/Mail.html b/samples/mail/src/com/google/gwt/sample/mail/public/Mail.html
index 4e95191..c17df75 100644
--- a/samples/mail/src/com/google/gwt/sample/mail/public/Mail.html
+++ b/samples/mail/src/com/google/gwt/sample/mail/public/Mail.html
@@ -1,8 +1,27 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+"http://www.w3.org/TR/html4/loose.dtd">
+
+<!--                                                                        -->
+<!-- Copyright 2008 Google Inc.                                             -->
+<!-- Licensed under the Apache License, Version 2.0 (the "License"); you    -->
+<!-- may not use this file except in compliance with the License. You may   -->
+<!-- may obtain a copy of the License at                                    -->
+<!--                                                                        -->
+<!-- http://www.apache.org/licenses/LICENSE-2.0                             -->
+<!--                                                                        -->
+<!-- Unless required by applicable law or agreed to in writing, software    -->
+<!-- distributed under the License is distributed on an "AS IS" BASIS,      -->
+<!-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        -->
+<!-- implied. License for the specific language governing permissions and   -->
+<!-- limitations under the License.                                         -->
+
 <html>
-	<head>
-		<title>Mail App</title>
-	</head>
-	<body>
-		<script language='javascript' src='com.google.gwt.sample.mail.Mail.nocache.js'></script>
-	</body>
+  <head>
+    <meta http-equiv="content-type" content="text/html; charset=UTF-8">
+    <title>Mail App</title>
+  </head>
+  <body>
+    <script type="text/javascript" language='javascript'
+      src='com.google.gwt.sample.mail.Mail.nocache.js'></script>
+  </body>
 </html>
diff --git a/samples/simplerpc/src/com/google/gwt/sample/simplerpc/public/SimpleRPC.html b/samples/simplerpc/src/com/google/gwt/sample/simplerpc/public/SimpleRPC.html
index f02c6af..406f66b 100644
--- a/samples/simplerpc/src/com/google/gwt/sample/simplerpc/public/SimpleRPC.html
+++ b/samples/simplerpc/src/com/google/gwt/sample/simplerpc/public/SimpleRPC.html
@@ -1,19 +1,33 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+ "http://www.w3.org/TR/html4/loose.dtd">
+ 
+<!--                                                                        -->
+<!-- Copyright 2008 Google Inc.                                             -->
+<!-- Licensed under the Apache License, Version 2.0 (the "License"); you    -->
+<!-- may not use this file except in compliance with the License. You may   -->
+<!-- may obtain a copy of the License at                                    -->
+<!--                                                                        -->
+<!-- http://www.apache.org/licenses/LICENSE-2.0                             -->
+<!--                                                                        -->
+<!-- Unless required by applicable law or agreed to in writing, software    -->
+<!-- distributed under the License is distributed on an "AS IS" BASIS,      -->
+<!-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        -->
+<!-- implied. License for the specific language governing permissions and   -->
+<!-- limitations under the License.                                         -->
+ 
+<html>
 	<head>
-		<meta name='gwt:module'
-			content='com.google.gwt.sample.simplerpc.SimpleRPC' />
-		<link type="text/css" rel="stylesheet" href="SimpleRPC.css" />
+	  <meta http-equiv="content-type" content="text/html; charset=UTF-8">
+		<link type="text/css" rel="stylesheet" href="SimpleRPC.css">
 		<title>SimpleRPC</title>
 	</head>
 	<body>
 		<iframe src="javascript:''" id='__gwt_historyFrame' style='width:0;height:0;border:0'></iframe>
-		<script type="text/javascript" language='javascript' src='gwt.js'>
+		<script type="text/javascript" language='javascript' src='com.google.gwt.sample.simplerpc.SimpleRPC.nocache.js'>
     </script>
-		<h1>
-			Simple RPC
-		</h1>
-		Simple example of RPC, check out the DynaTable sample if you want to see real RPC coolness. 
+		<h1> Simple RPC</h1>
+		<p>
+		  Simple example of RPC, check out the DynaTable sample if you want to see real RPC coolness. 
+		</p>
 	</body>
 </html>
diff --git a/samples/simplexml/src/com/google/gwt/sample/simplexml/public/SimpleXML.html b/samples/simplexml/src/com/google/gwt/sample/simplexml/public/SimpleXML.html
index a2a3522..a861394 100644
--- a/samples/simplexml/src/com/google/gwt/sample/simplexml/public/SimpleXML.html
+++ b/samples/simplexml/src/com/google/gwt/sample/simplexml/public/SimpleXML.html
@@ -1,9 +1,32 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+ "http://www.w3.org/TR/html4/loose.dtd">
+ 
+<!--                                                                        -->
+<!-- Copyright 2008 Google Inc.                                             -->
+<!-- Licensed under the Apache License, Version 2.0 (the "License"); you    -->
+<!-- may not use this file except in compliance with the License. You may   -->
+<!-- may obtain a copy of the License at                                    -->
+<!--                                                                        -->
+<!-- http://www.apache.org/licenses/LICENSE-2.0                             -->
+<!--                                                                        -->
+<!-- Unless required by applicable law or agreed to in writing, software    -->
+<!-- distributed under the License is distributed on an "AS IS" BASIS,      -->
+<!-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        -->
+<!-- implied. License for the specific language governing permissions and   -->
+<!-- limitations under the License.                                         -->
+ 
 <html>
-	<head>
+  <head>
+    <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 		<title>Simple XML Example</title>
-		<link rel="stylesheet" type="text/css" href="SimpleXML.css" />
+		<link rel="stylesheet" type="text/css" href="SimpleXML.css">
 	</head>
 	<body bgcolor="white"> 
-		<script language="javascript" src="com.google.gwt.sample.simplexml.SimpleXML.nocache.js"></script>
+		<script type="text/javascript" language="javascript" src="com.google.gwt.sample.simplexml.SimpleXML.nocache.js">
+		</script>
+		<h1> Simple XML Example</h1>
+		<p>
+		  Simple example of loading an XML file from the server and parsing it.
+		</p>
 	</body>
 </html>
diff --git a/user/src/com/google/gwt/user/tools/AppHtml.htmlsrc b/user/src/com/google/gwt/user/tools/AppHtml.htmlsrc
index 4013e1a..c92da8d 100644
--- a/user/src/com/google/gwt/user/tools/AppHtml.htmlsrc
+++ b/user/src/com/google/gwt/user/tools/AppHtml.htmlsrc
@@ -1,53 +1,66 @@
+
+<!-- <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" -->
+<!-- "http://www.w3.org/TR/html4/loose.dtd">                        -->
+
+<!-- The HTML 4.01 Transitional DOCTYPE declaration-->
+<!-- above set at the top of the file will set     -->
+<!-- the browser's rendering engine into           -->
+<!-- "Standards Mode", which gives better cross    -->
+<!-- browser compatibility to the application.     -->
+<!-- Omitting this line leaves most browsers in    -->
+<!-- "Quirks mode", emulating the bugs in older    -->
+<!-- browser versions.                             -->
+
 <html>
-	<head>
-	
-		<!--                                           -->
-		<!-- Any title is fine                         -->
-		<!--                                           -->
-		<title>Wrapper HTML for @className</title>
+  <head>
+    <meta http-equiv="content-type" content="text/html; charset=UTF-8">
+    <!--                                           -->
+    <!-- Any title is fine                         -->
+    <!--                                           -->
+    <title>Wrapper HTML for @className</title>
 
-		<!--                                           -->
-		<!-- Use normal html, such as style            -->
-		<!--                                           -->
-		<style>
-			body,td,a,div,.p{font-family:arial,sans-serif}
-			div,td{color:#000000}
-			a:link,.w,.w a:link{color:#0000cc}
-			a:visited{color:#551a8b}
-			a:active{color:#ff0000}
-		</style>
+    <!--                                           -->
+    <!-- Use normal html, such as style            -->
+    <!--                                           -->
+    <style type="text/css">
+      body,td,a,div,.p{font-family:arial,sans-serif}
+      div,td{color:#000000}
+      a:link,.w,.w a:link{color:#0000cc}
+      a:visited{color:#551a8b}
+      a:active{color:#ff0000}
+    </style>
+    
+    <!--                                           -->
+    <!-- This script loads your compiled module.   -->
+    <!-- If you add any GWT meta tags, they must   -->
+    <!-- be added before this line.                -->
+    <!--                                           -->
+    <script type="text/javascript" language="javascript" src="@moduleName.nocache.js"></script>
+  </head>
 
-		<!--                                           -->
-		<!-- This script loads your compiled module.   -->
-		<!-- If you add any GWT meta tags, they must   -->
-		<!-- be added before this line.                -->
-		<!--                                           -->
-		<script language='javascript' src='@moduleName.nocache.js'></script>
-	</head>
+  <!--                                           -->
+  <!-- The body can have arbitrary html, or      -->
+  <!-- you can leave the body empty if you want  -->
+  <!-- to create a completely dynamic UI.        -->
+  <!--                                           -->
+  <body>
 
-	<!--                                           -->
-	<!-- The body can have arbitrary html, or      -->
-	<!-- you can leave the body empty if you want  -->
-	<!-- to create a completely dynamic ui         -->
-	<!--                                           -->
-	<body>
+    <!-- OPTIONAL: include this if you want history support -->
+    <iframe src="javascript:''" id="__gwt_historyFrame" style="position:absolute;width:0;height:0;border:0"></iframe>
 
-		<!-- OPTIONAL: include this if you want history support -->
-		<iframe src="javascript:''" id="__gwt_historyFrame" style="position:absolute;width:0;height:0;border:0"></iframe>
+    <h1>@className</h1>
 
-		<h1>@className</h1>
-
-		<p>
-			This is an example of a host page for the @className application. 
-			You can attach a Web Toolkit module to any HTML page you like, 
-			making it easy to add bits of AJAX functionality to existing pages 
-			without starting from scratch.
-		</p>
-
-		<table align=center>
-			<tr>
-				<td id="slot1"></td><td id="slot2"></td>
-			</tr>
-		</table>
-	</body>
+    <p>
+      This is an example of a host page for the @className application. 
+      You can attach a Web Toolkit module to any HTML page you like, 
+      making it easy to add bits of AJAX functionality to existing pages 
+      without starting from scratch.
+    </p>
+    <table>
+	<tr>
+	  <td id="slot1"></td>
+	  <td id="slot2"></td>
+	</tr>
+    </table>
+  </body>
 </html>
