diff --git a/Makefile b/Makefile
index 188c81552..5e78649df 100644
--- a/Makefile
+++ b/Makefile
@@ -7,7 +7,7 @@ RUSTCFLAGS  := --opt-level=3
 RMFLAGS     :=
 
 # Output names
-EXES        := false printenv true yes cat whoami env wc
+EXES        := false printenv true yes cat whoami env wc echo
 TESTS       := cat
 
 # Utils stuff
diff --git a/README.md b/README.md
index a00a2e33d..0fe404faa 100644
--- a/README.md
+++ b/README.md
@@ -52,7 +52,6 @@ To do
 - dircolors
 - dirname
 - du
-- echo
 - expand
 - expr
 - extent-scan
diff --git a/echo/echo.rs b/echo/echo.rs
new file mode 100644
index 000000000..728b34797
--- /dev/null
+++ b/echo/echo.rs
@@ -0,0 +1,187 @@
+#[link(name="echo", vers="1.0.0", author="Derek Chiang")];
+
+/*
+ * This file is part of the uutils coreutils package.
+ *
+ * (c) Derek Chiang <derekchiang93@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+extern mod extra;
+
+use std::os;
+use std::io::stderr;
+use std::uint;
+use extra::getopts::groups;
+
+static VERSION: &'static str = "1.0.0";
+
+fn print_char(c: char) {
+    print!("{}", c);
+}
+
+fn to_char(bytes: &[u8], base: uint) -> char {
+    uint::parse_bytes(bytes, base).unwrap() as u8 as char
+}
+
+fn isxdigit(c: u8) -> bool {
+    match c as char {
+        '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' |
+        '8' | '9' | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' => true,
+        _ => false
+    }
+}
+
+fn isodigit(c: u8) -> bool {
+    match c as char {
+        '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' => true,
+        _ => false
+    }
+}
+
+fn convert_str(string: &str, index: uint, base: uint) -> (char, int) {
+    let (max_digits, is_legal_digit) = match base {
+        8u => (3, isodigit),
+        16u => (2, isxdigit),
+        _ => fail!(),
+    };
+
+    let mut bytes: ~[u8] = ~[];
+    for offset in range(0, max_digits) {
+        let c = string[index + offset as uint];
+        if is_legal_digit(c) {
+            bytes.push(c as u8);
+        } else {
+            if bytes.len() > 0 {
+                return (to_char(bytes, base), offset);
+            } else {
+                return (' ', offset);
+            }
+        }
+    }
+    return (to_char(bytes, base), max_digits)
+}
+
+fn main() {
+    let args = os::args();
+    let program = args[0].clone();
+    let opts = ~[
+        groups::optflag("n", "", "do not output the trailing newline"),
+        groups::optflag("e", "", "enable interpretation of backslash escapes"),
+        groups::optflag("E", "", "disable interpretation of backslash escapes (default)"),
+        groups::optflag("h", "help", "display this help and exit"),
+        groups::optflag("V", "version", "output version information and exit"),
+    ];
+
+    let matches = match groups::getopts(args.tail(), opts) {
+        Ok(m) => m,
+        Err(f) => {
+            writeln!(&mut stderr() as &mut Writer,
+                "Invalid options\n{}", f.to_err_msg());
+            os::set_exit_status(1);
+            return
+        }  
+    };
+
+    if matches.opt_present("help") {
+        println("echo " + VERSION + " - display a line of text");
+        println("");
+        println("Usage:");
+        println!("  {0:s} [SHORT-OPTION]... [STRING]...", program);
+        println!("  {0:s} LONG-OPTION", program);
+        println("");
+        print(groups::usage("Echo the STRING(s) to standard output.", opts));
+        print("\nIf -e is in effect, the following sequences are recognized:\n\
+\n\
+  \\\\      backslash\n\
+  \\a      alert (BEL)\n\
+  \\b      backspace\n\
+  \\c      produce no further output\n\
+  \\e      escape\n\
+  \\f      form feed\n\
+  \\n      new line\n\
+  \\r      carriage return\n\
+  \\t      horizontal tab\n\
+  \\v      vertical tab\n\
+  \\0NNN   byte with octal value NNN (1 to 3 digits)\n\
+  \\xHH    byte with hexadecimal value HH (1 to 2 digits)\n\
+");
+        return;
+    }
+
+    if matches.opt_present("version") {
+        return println("echo version: " + VERSION);
+    }
+
+    if !matches.free.is_empty() {
+        let string = matches.free.connect(" ");
+        if matches.opt_present("e") {
+            let mut prev_was_slash = false;
+            let mut iter = string.chars().enumerate();
+            loop {
+                match iter.next() {
+                    Some((index, c)) => {
+                        if !prev_was_slash {
+                            if c != '\\' {
+                                print_char(c);
+                            } else {
+                                prev_was_slash = true;
+                            }
+                        } else {
+                            prev_was_slash = false;
+                            match c {
+                                '\\' => print_char('\\'),
+                                'a' => print_char('\x07'),
+                                'b' => print_char('\x08'),
+                                'c' => break,
+                                'e' => print_char('\x1B'),
+                                'f' => print_char('\x0C'),
+                                'n' => print_char('\n'),
+                                'r' => print_char('\r'),
+                                't' => print_char('\t'),
+                                'v' => print_char('\x0B'),
+                                'x' => {
+                                    let (c, num_char_used) = convert_str(string, index + 1, 16u);
+                                    if num_char_used == 0 {
+                                        print_char('\\');
+                                        print_char('x');
+                                    } else {
+                                        print_char(c);
+                                        for _ in range(0, num_char_used) {
+                                            iter.next(); // consume used characters
+                                        }
+                                    }
+                                },
+                                '0' => {
+                                    let (c, num_char_used) = convert_str(string, index + 1, 8u);
+                                    if num_char_used == 0 {
+                                        print_char('\\');
+                                        print_char('0');
+                                    } else {
+                                        print_char(c);
+                                        for _ in range(0, num_char_used) {
+                                            iter.next(); // consume used characters
+                                        }
+                                    }
+                                }
+                                _ => {
+                                    print_char('\\');
+                                    print_char(c);
+                                }
+                            }
+                        }
+                    }
+                    None => break
+                }
+            }
+        } else {
+            print(string);
+        }
+    }
+
+    if !matches.opt_present("n") {
+        println("")
+    }
+}