diff --git a/user/super/com/google/gwt/emul/java/io/IOUtils.java b/user/super/com/google/gwt/emul/java/io/IOUtils.java
index b8d3049..118cba2 100644
--- a/user/super/com/google/gwt/emul/java/io/IOUtils.java
+++ b/user/super/com/google/gwt/emul/java/io/IOUtils.java
@@ -59,6 +59,23 @@
   }
 
   /**
+   * Validates the offset and the byte count for the given string.
+   *
+   * @param str String to be checked.
+   * @param offset Starting offset in the string.
+   * @param count Total number of characters to be accessed.
+   * @throws NullPointerException if the given reference to the string is null.
+   * @throws IndexOutOfBoundsException if {@code offset} is negative, {@code count} is
+   *     negative or their sum exceeds the string length.
+   */
+  public static void checkOffsetAndCount(String str, int offset, int count) {
+    // Ensure we throw a NullPointerException instead of a JavascriptException in case the
+    // given string is null.
+    checkNotNull(str);
+    checkOffsetAndCount(str.length(), offset, count);
+  }
+
+  /**
    * Validates the offset and the byte count for the given array length.
    *
    * @param length Length of the array to be checked.
diff --git a/user/super/com/google/gwt/emul/java/io/OutputStreamWriter.java b/user/super/com/google/gwt/emul/java/io/OutputStreamWriter.java
new file mode 100644
index 0000000..e03612d
--- /dev/null
+++ b/user/super/com/google/gwt/emul/java/io/OutputStreamWriter.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2020 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 java.io;
+
+import static javaemul.internal.InternalPreconditions.checkNotNull;
+
+import java.nio.charset.Charset;
+import javaemul.internal.EmulatedCharset;
+
+/**
+ * See <a href="http://java.sun.com/j2se/1.5.0/docs/api/java/io/OutputStreamWriter.html">the
+ * official Java API doc</a> for details.
+ */
+public class OutputStreamWriter extends Writer {
+
+  private final OutputStream out;
+
+  private final Charset charset;
+
+  public OutputStreamWriter(OutputStream out, String charsetName) {
+    this(out, Charset.forName(charsetName));
+  }
+
+  public OutputStreamWriter(OutputStream out, Charset charset) {
+    this.out = checkNotNull(out);
+    this.charset = checkNotNull(charset);
+  }
+
+  @Override
+  public void close() throws IOException {
+    out.close();
+  }
+
+  @Override
+  public void flush() throws IOException {
+    out.flush();
+  }
+
+  public String getEncoding() {
+    return charset.name();
+  }
+
+  @Override
+  public void write(char[] buffer, int offset, int count) throws IOException {
+    IOUtils.checkOffsetAndCount(buffer, offset, count);
+    byte[] byteBuffer = ((EmulatedCharset) charset).getBytes(buffer, offset, count);
+    out.write(byteBuffer, 0, byteBuffer.length);
+  }
+}
diff --git a/user/super/com/google/gwt/emul/java/io/Writer.java b/user/super/com/google/gwt/emul/java/io/Writer.java
new file mode 100644
index 0000000..4bba793
--- /dev/null
+++ b/user/super/com/google/gwt/emul/java/io/Writer.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright 2020 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 java.io;
+
+import static javaemul.internal.InternalPreconditions.checkNotNull;
+import static javaemul.internal.InternalPreconditions.checkPositionIndexes;
+
+import java.util.Objects;
+
+/**
+ * See <a href="http://java.sun.com/j2se/1.5.0/docs/api/java/io/Writer.html">the official Java API
+ * doc</a> for details.
+ */
+public abstract class Writer implements Appendable, Closeable, Flushable {
+
+  protected Writer() {}
+
+  protected Writer(Object lock) {}
+
+  public abstract void close() throws IOException;
+
+  public abstract void flush() throws IOException;
+
+  public void write(char[] buf) throws IOException {
+    // Ensure we throw a NullPointerException instead of a JavascriptException in case the
+    // given buffer is null.
+    checkNotNull(buf);
+    write(buf, 0, buf.length);
+  }
+
+  public abstract void write(char[] buf, int offset, int count) throws IOException;
+
+  public void write(int oneChar) throws IOException {
+    char[] oneCharArray = new char[1];
+    oneCharArray[0] = (char) oneChar;
+    write(oneCharArray);
+  }
+
+  public void write(String str) throws IOException {
+    // Ensure we throw a NullPointerException instead of a JavascriptException in case the
+    // given string is null.
+    checkNotNull(str);
+    write(str, 0, str.length());
+  }
+
+  public void write(String str, int offset, int count) throws IOException {
+    IOUtils.checkOffsetAndCount(str, offset, count);
+    char[] buf = new char[count];
+    str.getChars(offset, offset + count, buf, 0);
+    write(buf, 0, buf.length);
+  }
+
+  public Writer append(char c) throws IOException {
+    write(c);
+    return this;
+  }
+
+  public Writer append(CharSequence csq) throws IOException {
+    write(Objects.toString(csq));
+    return this;
+  }
+
+  public Writer append(CharSequence csq, int start, int end) throws IOException {
+    if (csq == null) {
+      csq = "null";
+    }
+    checkPositionIndexes(start, end, csq.length());
+    write(csq.subSequence(start, end).toString());
+    return this;
+  }
+}
diff --git a/user/super/com/google/gwt/emul/javaemul/internal/EmulatedCharset.java b/user/super/com/google/gwt/emul/javaemul/internal/EmulatedCharset.java
index ddde0fa..4cdf924 100644
--- a/user/super/com/google/gwt/emul/javaemul/internal/EmulatedCharset.java
+++ b/user/super/com/google/gwt/emul/javaemul/internal/EmulatedCharset.java
@@ -34,6 +34,16 @@
     }
 
     @Override
+    public byte[] getBytes(char[] buffer, int offset, int count) {
+      int n = offset + count;
+      byte[] bytes = new byte[count];
+      for (int i = offset; i < n; ++i) {
+        bytes[i] = (byte) (buffer[i] & 255);
+      }
+      return bytes;
+    }
+
+    @Override
     public byte[] getBytes(String str) {
       int n = str.length();
       byte[] bytes = new byte[n];
@@ -118,26 +128,23 @@
     }
 
     @Override
+    public byte[] getBytes(char[] buffer, int offset, int count) {
+      int n = offset + count;
+      byte[] bytes = new byte[0];
+      int out = 0;
+      for (int i = offset; i < n; ) {
+        int ch = Character.codePointAt(buffer, i, n);
+        i += Character.charCount(ch);
+        out += encodeUtf8(bytes, out, ch);
+      }
+      return bytes;
+    }
+
+    @Override
     public byte[] getBytes(String str) {
       // TODO(jat): consider using unescape(encodeURIComponent(bytes)) instead
       int n = str.length();
-      int byteCount = 0;
-      for (int i = 0; i < n;) {
-        int ch = str.codePointAt(i);
-        i += Character.charCount(ch);
-        if (ch < (1 << 7)) {
-          byteCount++;
-        } else if (ch < (1 << 11)) {
-          byteCount += 2;
-        } else if (ch < (1 << 16)) {
-          byteCount += 3;
-        } else if (ch < (1 << 21)) {
-          byteCount += 4;
-        } else if (ch < (1 << 26)) {
-          byteCount += 5;
-        }
-      }
-      byte[] bytes = new byte[byteCount];
+      byte[] bytes = new byte[0];
       int out = 0;
       for (int i = 0; i < n;) {
         int ch = str.codePointAt(i);
@@ -197,5 +204,7 @@
 
   public abstract byte[] getBytes(String string);
 
+  public abstract byte[] getBytes(char[] buffer, int offset, int count);
+
   public abstract char[] decodeString(byte[] bytes, int ofs, int len);
 }
diff --git a/user/test/com/google/gwt/emultest/EmulSuite.java b/user/test/com/google/gwt/emultest/EmulSuite.java
index 575fd5b..0d8bf9f 100644
--- a/user/test/com/google/gwt/emultest/EmulSuite.java
+++ b/user/test/com/google/gwt/emultest/EmulSuite.java
@@ -22,6 +22,8 @@
 import com.google.gwt.emultest.java.io.FilterOutputStreamTest;
 import com.google.gwt.emultest.java.io.InputStreamTest;
 import com.google.gwt.emultest.java.io.OutputStreamTest;
+import com.google.gwt.emultest.java.io.OutputStreamWriterTest;
+import com.google.gwt.emultest.java.io.WriterTest;
 import com.google.gwt.emultest.java.lang.BooleanTest;
 import com.google.gwt.emultest.java.lang.ByteTest;
 import com.google.gwt.emultest.java.lang.CharacterTest;
@@ -74,6 +76,8 @@
   FilterOutputStreamTest.class,
   InputStreamTest.class,
   OutputStreamTest.class,
+  OutputStreamWriterTest.class,
+  WriterTest.class,
 
   // -- java.lang
   BooleanTest.class,
diff --git a/user/test/com/google/gwt/emultest/java/io/OutputStreamWriterTest.java b/user/test/com/google/gwt/emultest/java/io/OutputStreamWriterTest.java
new file mode 100644
index 0000000..49ae2b2
--- /dev/null
+++ b/user/test/com/google/gwt/emultest/java/io/OutputStreamWriterTest.java
@@ -0,0 +1,126 @@
+/*
+ * Copyright 2020 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.emultest.java.io;
+
+import static java.nio.charset.StandardCharsets.UTF_8;
+
+import com.google.gwt.junit.client.GWTTestCase;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.io.UnsupportedEncodingException;
+import java.nio.charset.Charset;
+import java.util.Arrays;
+
+/**
+ * Unit test for the {@link java.io.OutputStreamWriter} emulated class.
+ */
+public class OutputStreamWriterTest extends GWTTestCase {
+
+  private final Charset encodingUTF8Charset = UTF_8;
+
+  /** String containing unicode characters. */
+  private static final String UNICODE_STRING = "ËÛëŶǾȜϞ";
+
+  /** Array of characters that contains ASCII characters. */
+  private static final char[] ASCII_CHAR_ARRAY = {'a', 'b', 'c', '"', '&', '<', '>'};
+
+  /** {@link java.io.OutputStreamWriter} object being tested. */
+  private OutputStreamWriter writer;
+
+  /** Underlying output stream used by the {@link OutputStreamWriter} object. */
+  private ByteArrayOutputStream baos;
+
+  /**
+   * Sets module name so that javascript compiler can operate.
+   */
+  @Override
+  public String getModuleName() {
+    return "com.google.gwt.emultest.EmulSuite";
+  }
+
+  @Override
+  protected void gwtSetUp() throws Exception {
+    super.gwtSetUp();
+    baos = new ByteArrayOutputStream();
+    writer = new OutputStreamWriter(baos, encodingUTF8Charset);
+  }
+
+  public void testNullCharset() throws UnsupportedEncodingException {
+    Charset nullCharset = null;
+    try {
+      new OutputStreamWriter(baos, nullCharset);
+      fail("should have thrown NullPointerException");
+    } catch (NullPointerException expected) {
+    }
+  }
+
+  public void testNullOutputStream() throws UnsupportedEncodingException {
+    try {
+      new OutputStreamWriter(/* out = */ null, encodingUTF8Charset);
+      fail("should have thrown NullPointerException");
+    } catch (NullPointerException expected) {
+    }
+  }
+
+  public void testWriteUnicodeChar() throws IOException {
+    writer.write(UNICODE_STRING, 0, UNICODE_STRING.length());
+    assertTrue(Arrays.equals(UNICODE_STRING.getBytes(encodingUTF8Charset), baos.toByteArray()));
+  }
+
+  public void testWriteASCIIChar() throws IOException {
+    writer.write(ASCII_CHAR_ARRAY, 0, ASCII_CHAR_ARRAY.length);
+    assertTrue(
+        Arrays.equals(
+            new String(ASCII_CHAR_ARRAY).getBytes(encodingUTF8Charset), baos.toByteArray()));
+  }
+
+  public void testWriteArrayUsingNullArray() throws IOException {
+    final char[] b = null;
+    try {
+      writer.write(b, 0, 2);
+      fail("should have thrown NullPointerException");
+    } catch (NullPointerException expected) {
+    }
+  }
+
+  public void testWriteArrayUsingNegativeOffsetValue() throws IOException {
+    final char[] b = {'a', 'b'};
+    try {
+      writer.write(b, -1, 1);
+      fail("should have thrown IndexOutOfBoundsException");
+    } catch (IndexOutOfBoundsException expected) {
+    }
+  }
+
+  public void testWriteArrayUsingNegativeLengthValue() throws IOException {
+    final char[] b = {'a', 'b'};
+    try {
+      writer.write(b, 0, -1);
+      fail("should have thrown IndexOutOfBoundsException");
+    } catch (IndexOutOfBoundsException expected) {
+    }
+  }
+
+  public void testWriteArrayUsingInvalidRangeValue() throws IOException {
+    final char[] b = {'a', 'b'};
+    try {
+      writer.write(b, 1, 2);
+      fail("should have thrown IndexOutOfBoundsException");
+    } catch (IndexOutOfBoundsException expected) {
+    }
+  }
+}
diff --git a/user/test/com/google/gwt/emultest/java/io/WriterTest.java b/user/test/com/google/gwt/emultest/java/io/WriterTest.java
new file mode 100644
index 0000000..7df1001
--- /dev/null
+++ b/user/test/com/google/gwt/emultest/java/io/WriterTest.java
@@ -0,0 +1,250 @@
+/*
+ * Copyright 2020 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.emultest.java.io;
+
+import com.google.gwt.junit.client.GWTTestCase;
+
+import java.io.IOException;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Unit test for the {@link java.io.Writer} emulated class.
+ */
+public class WriterTest extends GWTTestCase {
+
+  private TestWriter writer;
+
+  /**
+   * Instatiable version of {@link java.io.Writer} for testing purposes.
+   */
+  private static class TestWriter extends Writer {
+
+    private List<Character> outputChars = new ArrayList<>(1024);
+
+    @Override
+    public void close() {
+    }
+
+    @Override
+    public void flush() {
+    }
+
+    @Override
+    public void write(char[] cbuf, int off, int len) {
+      for (int i = off; i < (off + len); i++) {
+        outputChars.add(cbuf[i]);
+      }
+    }
+
+   /**
+    * Converts {@code outputChars} to primitive character array.
+    *
+    * @return primitive char array
+    */
+    public char[] toCharArray() {
+      if (outputChars.isEmpty()) {
+        return null;
+      }
+      char[] charArray = new char[outputChars.size()];
+      for (int i = 0; i < outputChars.size(); i++) {
+        charArray[i] = outputChars.get(i);
+      }
+      return charArray;
+    }
+  }
+
+  /**
+   * Sets module name so that javascript compiler can operate.
+   */
+  @Override
+  public String getModuleName() {
+    return "com.google.gwt.emultest.EmulSuite";
+  }
+
+  @Override
+  protected void gwtSetUp() throws Exception {
+    super.gwtSetUp();
+    writer = new TestWriter();
+  }
+
+  public void testAppendChar() throws IOException {
+    Writer w = writer.append('a');
+    assertEquals(writer, w);
+
+    assertTrue(Arrays.equals(new char[] { 'a' }, writer.toCharArray()));
+
+    w = writer.append('b');
+    assertEquals(writer, w);
+    assertTrue(Arrays.equals(new char[] { 'a', 'b' }, writer.toCharArray()));
+
+    w = writer.append('c');
+    assertEquals(writer, w);
+    assertTrue(Arrays.equals(new char[] { 'a', 'b', 'c' }, writer.toCharArray()));
+  }
+
+  public void testAppendNullCharSequence() throws IOException {
+    final Writer w = writer.append(null);
+    assertEquals(writer, w);
+    assertTrue(Arrays.equals("null".toCharArray(), writer.toCharArray()));
+  }
+
+  public void testAppendEmptyCharSequence() throws IOException {
+    final CharSequence csq = "";
+    final Writer w = writer.append(csq);
+    assertEquals(writer, w);
+    assertNull(writer.toCharArray());
+  }
+
+  public void testAppendNonEmptyCharSequence() throws IOException {
+    final CharSequence csq = "hola";
+    final Writer w = writer.append(csq);
+    assertEquals(writer, w);
+    assertTrue(Arrays.equals("hola".toCharArray(), writer.toCharArray()));
+  }
+
+  public void testAppendSubCharSequenceUsingNegativeStartValue() throws IOException {
+    final CharSequence csq = "hola";
+    try {
+      writer.append(csq, -1, 2);
+      fail("should have thrown IndexOutOfBoundsException");
+    } catch (IndexOutOfBoundsException expected) {
+    }
+  }
+
+  public void testAppendSubCharSequenceUsingNegativeEndValue() throws IOException {
+    final CharSequence csq = "hola";
+    try {
+      writer.append(csq, 0, -1);
+      fail("should have thrown IndexOutOfBoundsException");
+    } catch (IllegalArgumentException expected) {
+    }
+  }
+
+  public void testAppendSubCharSequenceStartIsGreaterThanEnd() throws IOException {
+    final CharSequence csq = "hola";
+    try {
+      writer.append(csq, 2, 1);
+      fail("should have thrown IndexOutOfBoundsException");
+    } catch (IllegalArgumentException expected) {
+    }
+  }
+
+  public void testAppendNullSubCharSequence() throws IOException {
+    final Writer w = writer.append(null, 1, "null".length() - 1);
+    assertEquals(writer, w);
+    assertTrue(Arrays.equals("ul".toCharArray(), writer.toCharArray()));
+  }
+
+  public void testAppendEmptySubCharSequence() throws IOException {
+    final CharSequence csq = "";
+    final Writer w = writer.append(csq, 0, 0);
+    assertEquals(writer, w);
+    assertNull(writer.toCharArray());
+  }
+
+  public void testAppendNonEmptySubCharSequence() throws IOException {
+    final CharSequence csq = "hola";
+    final Writer w = writer.append(csq, 1, "hola".length() - 1);
+    assertEquals(writer, w);
+    assertTrue(Arrays.equals("ol".toCharArray(), writer.toCharArray()));
+  }
+
+  public void testWriteChar() throws IOException {
+    writer.write('a');
+    assertTrue(Arrays.equals(new char[] { 'a' }, writer.toCharArray()));
+
+    writer.write('b');
+    assertTrue(Arrays.equals(new char[] { 'a', 'b' }, writer.toCharArray()));
+
+    writer.write('c');
+    assertTrue(Arrays.equals(new char[] { 'a', 'b', 'c' }, writer.toCharArray()));
+  }
+
+  public void testWriteEmptyCharArray() throws IOException {
+    final char[] charArray = new char[] { };
+    writer.write(charArray);
+    assertNull(writer.toCharArray());
+  }
+
+  public void testWriteNonEmptyCharArray() throws IOException {
+    final char[] charArray = "hola".toCharArray();
+    writer.write(charArray);
+    assertTrue(Arrays.equals(charArray, writer.toCharArray()));
+  }
+
+  public void testWriteEmptyString() throws IOException {
+    final String str = "";
+    writer.write(str);
+    assertNull(writer.toCharArray());
+  }
+
+  public void testWriteNullString() throws IOException {
+    try {
+      final String str = null;
+      writer.write(str);
+      fail("should have thrown NullPointerException");
+    } catch (NullPointerException expected) {
+    }
+  }
+
+  public void testWriteNonEmptyString() throws IOException {
+    final String str = "hola";
+    writer.write(str);
+    assertTrue(Arrays.equals(str.toCharArray(), writer.toCharArray()));
+  }
+
+  public void testWriteSubStringUsingNegativeStartValue() throws IOException {
+    final String str = "hola";
+    try {
+      writer.append(str, -1, 2);
+      fail("should have thrown IndexOutOfBoundsException");
+    } catch (IndexOutOfBoundsException expected) {
+    }
+  }
+
+  public void testWriteSubStringUsingNegativeEndValue() throws IOException {
+    final String str = "hola";
+    try {
+      writer.append(str, 0, -1);
+      fail("should have thrown IndexOutOfBoundsException");
+    } catch (IllegalArgumentException expected) {
+    }
+  }
+
+  public void testWriteSubStringStartIsGreaterThanEnd() throws IOException {
+    final String str = "hola";
+    try {
+      writer.append(str, 2, 1);
+      fail("should have thrown IndexOutOfBoundsException");
+    } catch (IllegalArgumentException expected) {
+    }
+  }
+
+  public void testWriteEmptySubstring() throws IOException {
+    final String str = "";
+    writer.write(str, 0, 0);
+    assertNull(writer.toCharArray());
+  }
+
+  public void testWriteNonEmptySubstring() throws IOException {
+    final String str = "hola";
+    writer.write(str, 1, 2);
+    assertTrue(Arrays.equals("ol".toCharArray(), writer.toCharArray()));
+  }
+}