diff --git a/common.ant.xml b/common.ant.xml
index 4070dfd..6708595 100755
--- a/common.ant.xml
+++ b/common.ant.xml
@@ -150,6 +150,7 @@
 				<classpath>
 					<pathelement location="${gwt.tools.lib}/junit/junit-3.8.1.jar" />
 					<pathelement location="${gwt.tools.antlib}/ant-junit-1.6.5.jar" />
+                                        <pathelement location="${gwt.tools.lib}/selenium/selenium-java-client-driver.jar" />
 				</classpath>
 			</taskdef>
 
@@ -171,6 +172,7 @@
 					<pathelement location="${javac.out}" />
 					<pathelement location="${gwt.dev.staging.jar}" />
 					<pathelement location="${gwt.tools.lib}/junit/junit-3.8.1.jar" />
+                                        <pathelement location="${gwt.tools.lib}/selenium/selenium-java-client-driver.jar" />
 					<extraclasspaths />
 				</classpath>
 
diff --git a/eclipse/user/.classpath b/eclipse/user/.classpath
index e7b1f4c..8e4fa1b 100644
--- a/eclipse/user/.classpath
+++ b/eclipse/user/.classpath
@@ -7,6 +7,7 @@
 	<classpathentry exported="true" kind="var" path="GWT_TOOLS/lib/apache/tapestry-util-text-4.0.2.jar" sourcepath="/GWT_TOOLS/lib/apache/tapestry-util-text-4.0.2-src.zip"/>
 	<classpathentry exported="true" kind="var" path="GWT_TOOLS/lib/junit/junit-3.8.1.jar" sourcepath="/GWT_TOOLS/lib/junit/junit-3.8.1-src.zip"/>
 	<classpathentry exported="true" kind="var" path="GWT_TOOLS/lib/tomcat/servlet-api-2.4.jar" sourcepath="/GWT_TOOLS/lib/tomcat/jakarta-tomcat-5.0.28-src.zip"/>
+	<classpathentry kind="var" path="GWT_TOOLS/lib/selenium/selenium-java-client-driver.jar"/>
 	<classpathentry combineaccessrules="false" kind="src" path="/gwt-dev-windows"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>
diff --git a/user/build.xml b/user/build.xml
index 3718922..8e85c2f 100755
--- a/user/build.xml
+++ b/user/build.xml
@@ -26,6 +26,7 @@
 				<pathelement location="${gwt.tools.lib}/tomcat/servlet-api-2.4.jar" />
 				<pathelement location="${gwt.tools.lib}/junit/junit-3.8.1.jar" />
 				<pathelement location="${gwt.tools.lib}/jfreechart/jfreechart-1.0.3.jar" />
+				<pathelement location="${gwt.tools.lib}/selenium/selenium-java-client-driver.jar" />
 				<pathelement location="${gwt.dev.jar}" />
 			</classpath>
 		</gwt.javac>
@@ -50,6 +51,7 @@
 				<pathelement location="${javac.out}" />
 				<pathelement location="${gwt.build}/out/dev/core/bin-test" />
 				<pathelement location="${gwt.tools.lib}/junit/junit-3.8.1.jar" />
+				<pathelement location="${gwt.tools.lib}/selenium/selenium-java-client-driver.jar" />
 				<pathelement location="${gwt.dev.staging.jar}" />
 			</classpath>
 		</gwt.javac>
@@ -62,6 +64,7 @@
 			<fileset dir="super" excludes="**/package.html" />
 			<fileset dir="${javac.out}" />
 			<zipfileset src="${gwt.tools.lib}/tomcat/servlet-api-2.4.jar" />
+		        <zipfileset src="${gwt.tools.lib}/selenium/selenium-java-client-driver.jar" />
 		</gwt.jar>
 	</target>
 
@@ -75,7 +78,16 @@
 
 	<target name="remoteweb-test" description="Run a remoteweb test at the given host and path" if="gwt.remote.browsers">
 		<echo message="Performing remote browser testing at ${gwt.remote.browsers}" />
-		<gwt.junit test.args="${test.args} -out www -web -remoteweb ${gwt.remote.browsers}" test.out="${junit.out}/remoteweb" test.cases="default.web.tests" >
+		<gwt.junit test.args="${test.args} -out www -remoteweb ${gwt.remote.browsers}" test.out="${junit.out}/remoteweb" test.cases="default.web.tests" >
+			<extraclasspaths>
+				<pathelement location="${gwt.build}/out/dev/core/bin-test" />
+			</extraclasspaths>
+		</gwt.junit>
+	</target>
+
+	<target name="selenium-test" description="Run a remote test using Selenium RC test at the given host and path" if="gwt.selenium.hosts">
+		<echo message="Performing remote browser testing using Selenium RC at ${gwt.selenium.hosts}" />
+		<gwt.junit test.args="${test.args} -out www -selenium ${gwt.selenium.hosts}" test.out="${junit.out}/selenium" test.cases="default.web.tests" >
 			<extraclasspaths>
 				<pathelement location="${gwt.build}/out/dev/core/bin-test" />
 			</extraclasspaths>
@@ -98,7 +110,7 @@
 		</gwt.junit>
 	</target>
 
-	<target name="test" depends="compile, compile.tests" description="Run hosted-mode, web-mode and remoteweb tests for this project.">
+	<target name="test" depends="compile, compile.tests" description="Run hosted-mode, web-mode, remoteweb, and selenium tests for this project.">
 		<property.ensure name="distro.built" location="${gwt.dev.staging.jar}" message="GWT must be built before performing any tests.  This can be fixed by running ant in the ${gwt.root} directory." />
 
 		<!--
@@ -107,6 +119,8 @@
 		-->
 		<limit failonerror="true" hours="2">
 		<parallel threadsPerProcessor="1">
+			<!-- selenium-test is a no-op unless gwt.selenium.hosts is defined -->
+			<antcall target="selenium-test"/>
 			<!-- remoteweb-test is a no-op unless gwt.remote.browsers is defined -->
 			<antcall target="remoteweb-test"/>
 			<antcall target="test.hosted"/>
diff --git a/user/src/com/google/gwt/junit/JUnitShell.java b/user/src/com/google/gwt/junit/JUnitShell.java
index 74d2837..f31a6fb 100644
--- a/user/src/com/google/gwt/junit/JUnitShell.java
+++ b/user/src/com/google/gwt/junit/JUnitShell.java
@@ -272,7 +272,8 @@
 
       @Override
       public String getPurpose() {
-        return "Runs web mode via RMI to a BrowserManagerServer; e.g. rmi://localhost/ie6";
+        return "Runs web mode via RMI to a set of BrowserManagerServers; "
+            + "e.g. rmi://localhost/ie6,rmi://localhost/firefox";
       }
 
       @Override
@@ -303,6 +304,33 @@
 
       @Override
       public String getPurpose() {
+        return "Runs web mode via HTTP to a set of Selenium servers; "
+            + "e.g. localhost:4444/*firefox,remotehost:4444/*iexplore";
+      }
+
+      @Override
+      public String getTag() {
+        return "-selenium";
+      }
+
+      @Override
+      public String[] getTagArgs() {
+        return new String[] {"seleniumHost"};
+      }
+
+      @Override
+      public boolean setString(String str) {
+        String[] targets = str.split(",");
+        numClients = targets.length;
+        runStyle = RunStyleSelenium.create(JUnitShell.this, targets);
+        return runStyle != null;
+      }
+    });
+
+    registerHandler(new ArgHandlerString() {
+
+      @Override
+      public String getPurpose() {
         return "Run external browsers in web mode (pass a comma separated list of executables.)";
       }
 
diff --git a/user/src/com/google/gwt/junit/RunStyleSelenium.java b/user/src/com/google/gwt/junit/RunStyleSelenium.java
new file mode 100644
index 0000000..c8d8baf
--- /dev/null
+++ b/user/src/com/google/gwt/junit/RunStyleSelenium.java
@@ -0,0 +1,202 @@
+/*
+ * 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 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. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.junit;
+
+import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.core.ext.UnableToCompleteException;
+
+import com.thoughtworks.selenium.DefaultSelenium;
+import com.thoughtworks.selenium.Selenium;
+import com.thoughtworks.selenium.SeleniumException;
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Runs in web mode via browsers managed by Selenium.
+ */
+public class RunStyleSelenium extends RunStyleRemote {
+
+  private static class RCSelenium {
+    final String browser;
+    final String host;
+    final int port;
+    Selenium selenium;
+
+    public RCSelenium(String browser, String host, int port) {
+      this.browser = browser;
+      this.host = host;
+      this.port = port;
+    }
+
+    public void createSelenium(String domain) {
+      this.selenium = new DefaultSelenium(host, port, browser, domain);
+    }
+
+    public String getBrowser() {
+      return browser;
+    }
+
+    public String getHost() {
+      return host;
+    }
+
+    public int getPort() {
+      return port;
+    }
+
+    public Selenium getSelenium() {
+      return selenium;
+    }
+  }
+
+  public static RunStyle create(JUnitShell shell, String[] targetsIn) {
+    RCSelenium targets[] = new RCSelenium[targetsIn.length];
+
+    Pattern pattern = Pattern.compile("([\\w\\.-]+):([\\d]+)/([\\w\\*]+)");
+    for (int i = 0; i < targets.length; ++i) {
+      Matcher matcher = pattern.matcher(targetsIn[i]);
+      if (!matcher.matches()) {
+        throw new JUnitFatalLaunchException("Unable to parse Selenium target "
+            + targets[i] + " (expected format is [host]:[port]/[browser])");
+      }
+      RCSelenium instance = new RCSelenium(matcher.group(3), matcher.group(1),
+          Integer.parseInt(matcher.group(2)));
+      targets[i] = instance;
+    }
+
+    return new RunStyleSelenium(shell, targets);
+  }
+
+  private RCSelenium remotes[];
+
+  /**
+   * Whether one of the remote browsers was interrupted.
+   */
+  private boolean wasInterrupted;
+
+  /**
+   * A separate lock to control access to {@link #wasInterrupted}. This keeps
+   * the main thread calls into {@link #wasInterrupted()} from having to be
+   * synchronized on the containing instance and potentially block on RPC calls.
+   * It is okay to take the {@link #wasInterruptedLock} while locking the
+   * containing instance; it is NOT okay to do the opposite or deadlock could
+   * occur.
+   */
+  private final Object wasInterruptedLock = new Object();
+
+  public RunStyleSelenium(final JUnitShell shell, RCSelenium targets[]) {
+
+    super(shell);
+    this.remotes = targets;
+
+    // Install a shutdown hook that will close all of our outstanding Selenium
+    // sessions.
+    Runtime.getRuntime().addShutdownHook(new Thread() {
+      @Override
+      public void run() {
+        for (RCSelenium remote : remotes) {
+          if (remote.getSelenium() != null) {
+            try {
+              remote.getSelenium().stop();
+            } catch (SeleniumException se) {
+              shell.getTopLogger().log(TreeLogger.WARN,
+                  "Error stoping selenium session", se);
+            }
+          }
+        }
+      }
+    });
+
+    // Crank up the keep-alive thread. This will periodically check for failure
+    // of the Selenium session and stop the test if something goes wrong.
+    Thread keepAliveThread = new Thread() {
+      @Override
+      public void run() {
+        do {
+          try {
+            Thread.sleep(1000);
+          } catch (InterruptedException ignored) {
+          }
+        } while (doKeepAlives());
+      }
+    };
+    keepAliveThread.setDaemon(true);
+    keepAliveThread.start();
+  }
+
+  @Override
+  public synchronized void launchModule(String moduleName)
+      throws UnableToCompleteException {
+    // Get the localhost address.
+    String domain;
+    try {
+      String localhost = InetAddress.getLocalHost().getHostAddress();
+      domain = "http://" + localhost + ":" + shell.getPort() + "/";
+    } catch (UnknownHostException e) {
+      throw new RuntimeException("Unable to determine my ip address", e);
+    }
+
+    // Startup all the selenia and point them at the module url.
+    for (RCSelenium remote : remotes) {
+      try {
+        shell.getTopLogger().log(TreeLogger.TRACE,
+            "Starting with domain: " + domain 
+            + " Opening URL: " + getMyUrl(moduleName)); 
+        remote.createSelenium(domain);
+        remote.getSelenium().start();
+        remote.getSelenium().open(getMyUrl(moduleName));
+      } catch (Exception e) {
+        shell.getTopLogger().log(TreeLogger.ERROR,
+            "Error launching browser via Selenium-RC at " + remote.getHost(), e);
+      }
+    }
+  }
+
+  @Override
+  public boolean wasInterrupted() {
+    synchronized (wasInterruptedLock) {
+      return wasInterrupted;
+    }
+  }
+
+  private synchronized boolean doKeepAlives() {
+    if (remotes != null) {
+      for (RCSelenium remote : remotes) {
+        // Use getTitle() as a cheap way to see if the Selenium server's still
+        // responding (Selenium seems to provide no way to check the server
+        // status directly).
+        try {
+          if (remote.getSelenium() != null) {
+            remote.getSelenium().getTitle();
+          }
+        } catch (Throwable e) {
+          setWasInterrupted(true);
+        }
+      }
+    }
+
+    return !wasInterrupted();
+  }
+
+  private void setWasInterrupted(boolean wasInterrupted) {
+    synchronized (wasInterruptedLock) {
+      this.wasInterrupted = wasInterrupted;
+    }
+  }
+}