diff --git a/src/doc/guide-ffi.md b/src/doc/guide-ffi.md
index d4267fd57a4..9f2f2b34c2e 100644
--- a/src/doc/guide-ffi.md
+++ b/src/doc/guide-ffi.md
@@ -285,7 +285,7 @@ extern {
 
 fn main() {
     // Create the object that will be referenced in the callback
-    let mut rust_object = ~RustObject{ a: 5 };
+    let mut rust_object = box RustObject { a: 5 };
 
     unsafe {
         register_callback(&mut *rust_object, callback);
diff --git a/src/doc/guide-lifetimes.md b/src/doc/guide-lifetimes.md
index c734eccddc0..48c50471c25 100644
--- a/src/doc/guide-lifetimes.md
+++ b/src/doc/guide-lifetimes.md
@@ -41,9 +41,9 @@ point, but allocated in a different place:
 
 ~~~
 # struct Point {x: f64, y: f64}
-let on_the_stack :  Point =  Point {x: 3.0, y: 4.0};
-let managed_box  : @Point = @Point {x: 5.0, y: 1.0};
-let owned_box    : ~Point = ~Point {x: 7.0, y: 9.0};
+let on_the_stack :  Point     =     Point {x: 3.0, y: 4.0};
+let managed_box  : @Point     =    @Point {x: 5.0, y: 1.0};
+let owned_box    : Box<Point> = box Point {x: 7.0, y: 9.0};
 ~~~
 
 Suppose we wanted to write a procedure that computed the distance between any
@@ -72,9 +72,9 @@ Now we can call `compute_distance()` in various ways:
 
 ~~~
 # struct Point {x: f64, y: f64}
-# let on_the_stack :  Point =  Point{x: 3.0, y: 4.0};
-# let managed_box  : @Point = @Point{x: 5.0, y: 1.0};
-# let owned_box    : ~Point = ~Point{x: 7.0, y: 9.0};
+# let on_the_stack :     Point  =     Point{x: 3.0, y: 4.0};
+# let managed_box  :    @Point  =    @Point{x: 5.0, y: 1.0};
+# let owned_box    : Box<Point> = box Point{x: 7.0, y: 9.0};
 # fn compute_distance(p1: &Point, p2: &Point) -> f64 { 0.0 }
 compute_distance(&on_the_stack, managed_box);
 compute_distance(managed_box, owned_box);
@@ -151,12 +151,12 @@ Now, as before, we can define rectangles in a few different ways:
 # struct Point {x: f64, y: f64}
 # struct Size {w: f64, h: f64} // as before
 # struct Rectangle {origin: Point, size: Size}
-let rect_stack   = &Rectangle {origin: Point {x: 1.0, y: 2.0},
-                               size: Size {w: 3.0, h: 4.0}};
-let rect_managed = @Rectangle {origin: Point {x: 3.0, y: 4.0},
-                               size: Size {w: 3.0, h: 4.0}};
-let rect_owned   = ~Rectangle {origin: Point {x: 5.0, y: 6.0},
-                               size: Size {w: 3.0, h: 4.0}};
+let rect_stack   =    &Rectangle {origin: Point {x: 1.0, y: 2.0},
+                                  size: Size {w: 3.0, h: 4.0}};
+let rect_managed =    @Rectangle {origin: Point {x: 3.0, y: 4.0},
+                                  size: Size {w: 3.0, h: 4.0}};
+let rect_owned   = box Rectangle {origin: Point {x: 5.0, y: 6.0},
+                                  size: Size {w: 3.0, h: 4.0}};
 ~~~
 
 In each case, we can extract out individual subcomponents with the `&`
@@ -168,7 +168,7 @@ operator. For example, I could write:
 # struct Rectangle {origin: Point, size: Size}
 # let rect_stack  = &Rectangle {origin: Point {x: 1.0, y: 2.0}, size: Size {w: 3.0, h: 4.0}};
 # let rect_managed = @Rectangle {origin: Point {x: 3.0, y: 4.0}, size: Size {w: 3.0, h: 4.0}};
-# let rect_owned = ~Rectangle {origin: Point {x: 5.0, y: 6.0}, size: Size {w: 3.0, h: 4.0}};
+# let rect_owned = box Rectangle {origin: Point {x: 5.0, y: 6.0}, size: Size {w: 3.0, h: 4.0}};
 # fn compute_distance(p1: &Point, p2: &Point) -> f64 { 0.0 }
 compute_distance(&rect_stack.origin, &rect_managed.origin);
 ~~~
@@ -276,12 +276,12 @@ the following function is legal:
 # fn some_condition() -> bool { true }
 # struct Foo { f: int }
 fn example3() -> int {
-    let mut x = ~Foo {f: 3};
+    let mut x = box Foo {f: 3};
     if some_condition() {
         let y = &x.f;      // -+ L
         return *y;         //  |
     }                      // -+
-    x = ~Foo {f: 4};
+    x = box Foo {f: 4};
     // ...
 # return 0;
 }
@@ -301,9 +301,9 @@ rejected by the compiler):
 
 ~~~ {.ignore}
 fn example3() -> int {
-    let mut x = ~X {f: 3};
+    let mut x = box X {f: 3};
     let y = &x.f;
-    x = ~X {f: 4};  // Error reported here.
+    x = box X {f: 4};  // Error reported here.
     *y
 }
 ~~~
@@ -314,13 +314,13 @@ memory immediately before the re-assignment of `x`:
 ~~~ {.notrust}
     Stack               Exchange Heap
 
-  x +----------+
-    | ~{f:int} | ----+
-  y +----------+     |
-    | &int     | ----+
-    +----------+     |    +---------+
-                     +--> |  f: 3   |
-                          +---------+
+  x +-------------+
+    | box {f:int} | ----+
+  y +-------------+     |
+    | &int        | ----+
+    +-------------+     |    +---------+
+                        +--> |  f: 3   |
+                             +---------+
 ~~~
 
 Once the reassignment occurs, the memory will look like this:
@@ -328,13 +328,13 @@ Once the reassignment occurs, the memory will look like this:
 ~~~ {.notrust}
     Stack               Exchange Heap
 
-  x +----------+          +---------+
-    | ~{f:int} | -------> |  f: 4   |
-  y +----------+          +---------+
-    | &int     | ----+
-    +----------+     |    +---------+
-                     +--> | (freed) |
-                          +---------+
+  x +-------------+          +---------+
+    | box {f:int} | -------> |  f: 4   |
+  y +-------------+          +---------+
+    | &int        | ----+
+    +-------------+     |    +---------+
+                        +--> | (freed) |
+                             +---------+
 ~~~
 
 Here you can see that the variable `y` still points at the old box,
@@ -349,12 +349,12 @@ mutations:
 ~~~ {.ignore}
 fn example3() -> int {
     struct R { g: int }
-    struct S { f: ~R }
+    struct S { f: Box<R> }
 
-    let mut x = ~S {f: ~R {g: 3}};
+    let mut x = box S {f: box R {g: 3}};
     let y = &x.f.g;
-    x = ~S {f: ~R {g: 4}};  // Error reported here.
-    x.f = ~R {g: 5};        // Error reported here.
+    x = box S {f: box R {g: 4}};  // Error reported here.
+    x.f = box R {g: 5};           // Error reported here.
     *y
 }
 ~~~
diff --git a/src/doc/guide-pointers.md b/src/doc/guide-pointers.md
index fa813073cd9..46564e67128 100644
--- a/src/doc/guide-pointers.md
+++ b/src/doc/guide-pointers.md
@@ -182,13 +182,14 @@ trait. Therefore, unboxed traits don't make any sense, and aren't allowed.
 Sometimes, you need a recursive data structure. The simplest is known as a 'cons list':
 
 ~~~rust
+
 enum List<T> {
     Nil,
-    Cons(T, ~List<T>),
+    Cons(T, Box<List<T>>),
 }
 
 fn main() {
-    let list: List<int> = Cons(1, ~Cons(2, ~Cons(3, ~Nil)));
+    let list: List<int> = Cons(1, box Cons(2, box Cons(3, box Nil)));
     println!("{:?}", list);
 }
 ~~~
@@ -196,7 +197,7 @@ fn main() {
 This prints:
 
 ~~~ {.notrust}
-Cons(1, ~Cons(2, ~Cons(3, ~Nil)))
+Cons(1, box Cons(2, box Cons(3, box Nil)))
 ~~~
 
 The inner lists _must_ be an owned pointer, because we can't know how many
@@ -237,7 +238,7 @@ struct Point {
 }
 
 fn main() {
-    let a = ~Point { x: 10, y: 20 };
+    let a = box Point { x: 10, y: 20 };
     spawn(proc() {
         println!("{}", a.x);
     });
@@ -268,7 +269,7 @@ struct Point {
 }
 
 fn main() {
-    let a = ~Point { x: 10, y: 20 };
+    let a = box Point { x: 10, y: 20 };
     let b = a;
     println!("{}", b.x);
     println!("{}", a.x);
@@ -285,7 +286,7 @@ note: in expansion of format_args!
 <std-macros>:158:27: 158:81 note: expansion site
 <std-macros>:157:5: 159:6 note: in expansion of println!
 test.rs:10:5: 10:25 note: expansion site
-test.rs:8:9: 8:10 note: `a` moved here because it has type `~Point`, which is moved by default (use `ref` to override)
+test.rs:8:9: 8:10 note: `a` moved here because it has type `Box<Point>`, which is moved by default (use `ref` to override)
 test.rs:8     let b = a;
                   ^
 ~~~
@@ -345,8 +346,8 @@ fn compute_distance(p1: &Point, p2: &Point) -> f32 {
 }
 
 fn main() {
-    let origin = @Point { x: 0.0, y: 0.0 };
-    let p1     = ~Point { x: 5.0, y: 3.0 };
+    let origin =    @Point { x: 0.0, y: 0.0 };
+    let p1     = box Point { x: 5.0, y: 3.0 };
 
     println!("{:?}", compute_distance(origin, p1));
 }
@@ -381,7 +382,7 @@ duration a 'lifetime'. Let's try a more complex example:
 
 ~~~rust
 fn main() {
-    let mut x = ~5;
+    let mut x = box 5;
     if *x < 10 {
         let y = &x;
         println!("Oh no: {:?}", y);
@@ -398,7 +399,7 @@ mutated, and therefore, lets us pass. This wouldn't work:
 
 ~~~rust{.ignore}
 fn main() {
-    let mut x = ~5;
+    let mut x = box 5;
     if *x < 10 {
         let y = &x;
         *x -= 1;
@@ -437,12 +438,12 @@ is best.
 What does that mean? Don't do this:
 
 ~~~rust
-fn foo(x: ~int) -> ~int {
-    return ~*x;
+fn foo(x: Box<int>) -> Box<int> {
+    return box *x;
 }
 
 fn main() {
-    let x = ~5;
+    let x = box 5;
     let y = foo(x);
 }
 ~~~
@@ -450,13 +451,13 @@ fn main() {
 Do this:
 
 ~~~rust
-fn foo(x: ~int) -> int {
+fn foo(x: Box<int>) -> int {
     return *x;
 }
 
 fn main() {
-    let x = ~5;
-    let y = ~foo(x);
+    let x = box 5;
+    let y = box foo(x);
 }
 ~~~
 
@@ -464,12 +465,12 @@ This gives you flexibility, without sacrificing performance. For example, this w
 also work:
 
 ~~~rust
-fn foo(x: ~int) -> int {
+fn foo(x: Box<int>) -> int {
     return *x;
 }
 
 fn main() {
-    let x = ~5;
+    let x = box 5;
     let y = @foo(x);
 }
 ~~~
diff --git a/src/doc/guide-unsafe.md b/src/doc/guide-unsafe.md
index 300c5bae964..fc6a12b495e 100644
--- a/src/doc/guide-unsafe.md
+++ b/src/doc/guide-unsafe.md
@@ -258,10 +258,10 @@ impl<T: Send> Drop for Unique<T> {
     }
 }
 
-// A comparison between the built-in ~ and this reimplementation
+// A comparison between the built-in `Box` and this reimplementation
 fn main() {
     {
-        let mut x = ~5;
+        let mut x = box 5;
         *x = 10;
     } // `x` is freed here
 
diff --git a/src/doc/intro.md b/src/doc/intro.md
index 94cbc8e0e0a..71356eba6d9 100644
--- a/src/doc/intro.md
+++ b/src/doc/intro.md
@@ -127,12 +127,13 @@ That's a great example for stack memory,
 but what about heap memory?
 Rust has a second kind of pointer,
 an 'owned box',
-that you can create with a `~`.
+that you can create with the `box` operator.
 Check it out:
 
 ```
-fn dangling() -> ~int {
-    let i = ~1234;
+
+fn dangling() -> Box<int> {
+    let i = box 1234;
     return i;
 }
 
@@ -143,7 +144,7 @@ fn add_one() -> int {
 ```
 
 Now instead of a stack allocated `1234`,
-we have a heap allocated `~1234`.
+we have a heap allocated `box 1234`.
 Whereas `&` borrows a pointer to existing memory,
 creating an owned box allocates memory on the heap and places a value in it,
 giving you the sole pointer to that memory.
@@ -151,7 +152,7 @@ You can roughly compare these two lines:
 
 ```
 // Rust
-let i = ~1234;
+let i = box 1234;
 ```
 
 ```notrust
diff --git a/src/doc/rust.md b/src/doc/rust.md
index cc99b1a4ab5..b6237e2a20f 100644
--- a/src/doc/rust.md
+++ b/src/doc/rust.md
@@ -1400,7 +1400,7 @@ to pointers to the trait name, used as a type.
 # trait Shape { }
 # impl Shape for int { }
 # let mycircle = 0;
-let myshape: ~Shape = ~mycircle as ~Shape;
+let myshape: Box<Shape> = box mycircle as Box<Shape>;
 ~~~~
 
 The resulting value is a managed box containing the value that was cast,
@@ -3048,19 +3048,19 @@ stands for a *single* data field, whereas a wildcard `..` stands for *all* the
 fields of a particular variant. For example:
 
 ~~~~
-enum List<X> { Nil, Cons(X, ~List<X>) }
+enum List<X> { Nil, Cons(X, Box<List<X>>) }
 
-let x: List<int> = Cons(10, ~Cons(11, ~Nil));
+let x: List<int> = Cons(10, box Cons(11, box Nil));
 
 match x {
-    Cons(_, ~Nil) => fail!("singleton list"),
-    Cons(..)      => return,
-    Nil           => fail!("empty list")
+    Cons(_, box Nil) => fail!("singleton list"),
+    Cons(..)         => return,
+    Nil              => fail!("empty list")
 }
 ~~~~
 
 The first pattern matches lists constructed by applying `Cons` to any head
-value, and a tail value of `~Nil`. The second pattern matches _any_ list
+value, and a tail value of `box Nil`. The second pattern matches _any_ list
 constructed with `Cons`, ignoring the values of its arguments. The difference
 between `_` and `..` is that the pattern `C(_)` is only type-correct if `C` has
 exactly one argument, while the pattern `C(..)` is type-correct for any enum
@@ -3110,12 +3110,12 @@ An example of a `match` expression:
 # fn process_pair(a: int, b: int) { }
 # fn process_ten() { }
 
-enum List<X> { Nil, Cons(X, ~List<X>) }
+enum List<X> { Nil, Cons(X, Box<List<X>>) }
 
-let x: List<int> = Cons(10, ~Cons(11, ~Nil));
+let x: List<int> = Cons(10, box Cons(11, box Nil));
 
 match x {
-    Cons(a, ~Cons(b, _)) => {
+    Cons(a, box Cons(b, _)) => {
         process_pair(a,b);
     }
     Cons(10, _) => {
@@ -3142,17 +3142,17 @@ Subpatterns can also be bound to variables by the use of the syntax
 For example:
 
 ~~~~
-enum List { Nil, Cons(uint, ~List) }
+enum List { Nil, Cons(uint, Box<List>) }
 
 fn is_sorted(list: &List) -> bool {
     match *list {
-        Nil | Cons(_, ~Nil) => true,
-        Cons(x, ref r @ ~Cons(y, _)) => (x <= y) && is_sorted(*r)
+        Nil | Cons(_, box Nil) => true,
+        Cons(x, ref r @ box Cons(y, _)) => (x <= y) && is_sorted(*r)
     }
 }
 
 fn main() {
-    let a = Cons(6, ~Cons(7, ~Cons(42, ~Nil)));
+    let a = Cons(6, box Cons(7, box Cons(42, box Nil)));
     assert!(is_sorted(&a));
 }
 
@@ -3429,10 +3429,10 @@ An example of a *recursive* type and its use:
 ~~~~
 enum List<T> {
   Nil,
-  Cons(T, ~List<T>)
+  Cons(T, Box<List<T>>)
 }
 
-let a: List<int> = Cons(7, ~Cons(13, ~Nil));
+let a: List<int> = Cons(7, box Cons(13, box Nil));
 ~~~~
 
 ### Pointer types
@@ -3581,12 +3581,12 @@ impl Printable for int {
   fn to_string(&self) -> ~str { self.to_str() }
 }
 
-fn print(a: ~Printable) {
+fn print(a: Box<Printable>) {
    println!("{}", a.to_string());
 }
 
 fn main() {
-   print(~10 as ~Printable);
+   print(box 10 as Box<Printable>);
 }
 ~~~~
 
@@ -3773,7 +3773,7 @@ mutable slot by prefixing them with `mut` (similar to regular arguments):
 ~~~
 trait Changer {
     fn change(mut self) -> Self;
-    fn modify(mut ~self) -> ~Self;
+    fn modify(mut ~self) -> Box<Self>;
 }
 ~~~
 
@@ -3786,12 +3786,14 @@ initialized; this is enforced by the compiler.
 ### Owned boxes
 
 An  _owned box_ is a reference to a heap allocation holding another value, which is constructed
-by the prefix *tilde* sigil `~`.
+by the prefix operator `box`. When the standard library is in use, the type of an owned box is
+`std::owned::Box<T>`.
 
 An example of an owned box type and value:
 
 ~~~~
-let x: ~int = ~10;
+
+let x: Box<int> = box 10;
 ~~~~
 
 Owned box values exist in 1:1 correspondence with their heap allocation
@@ -3799,7 +3801,7 @@ copying an owned box value makes a shallow copy of the pointer
 Rust will consider a shallow copy of an owned box to move ownership of the value. After a value has been moved, the source location cannot be used unless it is reinitialized.
 
 ~~~~
-let x: ~int = ~10;
+let x: Box<int> = box 10;
 let y = x;
 // attempting to use `x` will result in an error here
 ~~~~
diff --git a/src/doc/tutorial.md b/src/doc/tutorial.md
index 22c85b6513f..56f9e8e5cbd 100644
--- a/src/doc/tutorial.md
+++ b/src/doc/tutorial.md
@@ -911,12 +911,12 @@ Objects are never accessible after their destructor has been called, so no
 dynamic failures are possible from accessing freed resources. When a task
 fails, destructors of all objects in the task are called.
 
-The `~` sigil represents a unique handle for a memory allocation on the heap:
+The `box` operator performs memory allocation on the heap:
 
 ~~~~
 {
     // an integer allocated on the heap
-    let y = ~10;
+    let y = box 10;
 }
 // the destructor frees the heap memory as soon as `y` goes out of scope
 ~~~~
@@ -938,17 +938,17 @@ and destroy the contained object when they go out of scope.
 
 ~~~~
 // the struct owns the objects contained in the `x` and `y` fields
-struct Foo { x: int, y: ~int }
+struct Foo { x: int, y: Box<int> }
 
 {
     // `a` is the owner of the struct, and thus the owner of the struct's fields
-    let a = Foo { x: 5, y: ~10 };
+    let a = Foo { x: 5, y: box 10 };
 }
 // when `a` goes out of scope, the destructor for the `~int` in the struct's
 // field is called
 
 // `b` is mutable, and the mutability is inherited by the objects it owns
-let mut b = Foo { x: 5, y: ~10 };
+let mut b = Foo { x: 5, y: box 10 };
 b.x = 10;
 ~~~~
 
@@ -1021,13 +1021,15 @@ Our previous attempt at defining the `List` type included an `u32` and a `List`
 directly inside `Cons`, making it at least as big as the sum of both types. The
 type was invalid because the size was infinite!
 
-An *owned box* (`~`) uses a dynamic memory allocation to provide the invariant
-of always being the size of a pointer, regardless of the contained type. This
-can be leveraged to create a valid `List` definition:
+An *owned box* (`Box`, located in the `std::owned` module) uses a dynamic memory
+allocation to provide the invariant of always being the size of a pointer,
+regardless of the contained type. This can be leveraged to create a valid `List`
+definition:
 
 ~~~
+
 enum List {
-    Cons(u32, ~List),
+    Cons(u32, Box<List>),
     Nil
 }
 ~~~
@@ -1040,10 +1042,10 @@ Consider an instance of our `List` type:
 
 ~~~
 # enum List {
-#     Cons(u32, ~List),
+#     Cons(u32, Box<List>),
 #     Nil
 # }
-let list = Cons(1, ~Cons(2, ~Cons(3, ~Nil)));
+let list = Cons(1, box Cons(2, box Cons(3, box Nil)));
 ~~~
 
 It represents an owned tree of values, inheriting mutability down the tree and
@@ -1054,7 +1056,7 @@ box, while the owner holds onto a pointer to it:
 ~~~ {.notrust}
             List box            List box            List box          List box
         +--------------+    +--------------+    +--------------+    +----------+
-list -> | Cons | 1 | ~ | -> | Cons | 2 | ~ | -> | Cons | 3 | ~ | -> | Nil      |
+list -> | Cons | 1 |   | -> | Cons | 2 |   | -> | Cons | 3 |   | -> | Nil      |
         +--------------+    +--------------+    +--------------+    +----------+
 ~~~
 
@@ -1074,10 +1076,10 @@ the box rather than doing an implicit heap allocation.
 
 ~~~
 # enum List {
-#     Cons(u32, ~List),
+#     Cons(u32, Box<List>),
 #     Nil
 # }
-let xs = Cons(1, ~Cons(2, ~Cons(3, ~Nil)));
+let xs = Cons(1, box Cons(2, box Cons(3, box Nil)));
 let ys = xs; // copies `Cons(u32, pointer)` shallowly
 ~~~
 
@@ -1087,7 +1089,7 @@ location cannot be used unless it is reinitialized.
 
 ~~~
 # enum List {
-#     Cons(u32, ~List),
+#     Cons(u32, Box<List>),
 #     Nil
 # }
 let mut xs = Nil;
@@ -1107,7 +1109,7 @@ as it is only called a single time.
 Avoiding a move can be done with the library-defined `clone` method:
 
 ~~~~
-let x = ~5;
+let x = box 5;
 let y = x.clone(); // `y` is a newly allocated box
 let z = x; // no new memory allocated, `x` can no longer be used
 ~~~~
@@ -1118,11 +1120,11 @@ our `List` type. Traits will be explained in detail [later](#traits).
 ~~~{.ignore}
 #[deriving(Clone)]
 enum List {
-    Cons(u32, ~List),
+    Cons(u32, Box<List>),
     Nil
 }
 
-let x = Cons(5, ~Nil);
+let x = Cons(5, box Nil);
 let y = x.clone();
 
 // `x` can still be used!
@@ -1135,7 +1137,7 @@ let z = x;
 The mutability of a value may be changed by moving it to a new owner:
 
 ~~~~
-let r = ~13;
+let r = box 13;
 let mut s = r; // box becomes mutable
 *s += 1;
 let t = s; // box becomes immutable
@@ -1146,12 +1148,12 @@ advantage of moves:
 
 ~~~
 enum List {
-    Cons(u32, ~List),
+    Cons(u32, Box<List>),
     Nil
 }
 
 fn prepend(xs: List, value: u32) -> List {
-    Cons(value, ~xs)
+    Cons(value, box xs)
 }
 
 let mut xs = Nil;
@@ -1186,7 +1188,7 @@ by-value. A recursive definition of equality using references is as follows:
 
 ~~~
 # enum List {
-#     Cons(u32, ~List),
+#     Cons(u32, Box<List>),
 #     Nil
 # }
 fn eq(xs: &List, ys: &List) -> bool {
@@ -1195,15 +1197,15 @@ fn eq(xs: &List, ys: &List) -> bool {
         // If we have reached the end of both lists, they are equal.
         (&Nil, &Nil) => true,
         // If the current elements of both lists are equal, keep going.
-        (&Cons(x, ~ref next_xs), &Cons(y, ~ref next_ys))
+        (&Cons(x, box ref next_xs), &Cons(y, box ref next_ys))
                 if x == y => eq(next_xs, next_ys),
         // If the current elements are not equal, the lists are not equal.
         _ => false
     }
 }
 
-let xs = Cons(5, ~Cons(10, ~Nil));
-let ys = Cons(5, ~Cons(10, ~Nil));
+let xs = Cons(5, box Cons(10, box Nil));
+let ys = Cons(5, box Cons(10, box Nil));
 assert!(eq(&xs, &ys));
 ~~~
 
@@ -1223,7 +1225,7 @@ The `u32` in the previous definition can be substituted with a type parameter:
 
 ~~~
 enum List<T> {
-    Cons(T, ~List<T>),
+    Cons(T, Box<List<T>>),
     Nil
 }
 ~~~
@@ -1233,11 +1235,11 @@ definition has to be updated too:
 
 ~~~
 # enum List<T> {
-#     Cons(T, ~List<T>),
+#     Cons(T, Box<List<T>>),
 #     Nil
 # }
 fn prepend<T>(xs: List<T>, value: T) -> List<T> {
-    Cons(value, ~xs)
+    Cons(value, box xs)
 }
 ~~~
 
@@ -1248,11 +1250,11 @@ Using the generic `List<T>` works much like before, thanks to type inference:
 
 ~~~
 # enum List<T> {
-#     Cons(T, ~List<T>),
+#     Cons(T, Box<List<T>>),
 #     Nil
 # }
 # fn prepend<T>(xs: List<T>, value: T) -> List<T> {
-#     Cons(value, ~xs)
+#     Cons(value, box xs)
 # }
 let mut xs = Nil; // Unknown type! This is a `List<T>`, but `T` can be anything.
 xs = prepend(xs, 10); // Here the compiler infers `xs`'s type as `List<int>`.
@@ -1265,11 +1267,11 @@ equivalent to the following type-annotated code:
 
 ~~~
 # enum List<T> {
-#     Cons(T, ~List<T>),
+#     Cons(T, Box<List<T>>),
 #     Nil
 # }
 # fn prepend<T>(xs: List<T>, value: T) -> List<T> {
-#     Cons(value, ~xs)
+#     Cons(value, box xs)
 # }
 let mut xs: List<int> = Nil::<int>;
 xs = prepend::<int>(xs, 10);
@@ -1293,7 +1295,7 @@ Two more `ref` annotations need to be added to avoid attempting to move out the
 
 ~~~
 # enum List<T> {
-#     Cons(T, ~List<T>),
+#     Cons(T, Box<List<T>>),
 #     Nil
 # }
 fn eq<T: Eq>(xs: &List<T>, ys: &List<T>) -> bool {
@@ -1302,15 +1304,15 @@ fn eq<T: Eq>(xs: &List<T>, ys: &List<T>) -> bool {
         // If we have reached the end of both lists, they are equal.
         (&Nil, &Nil) => true,
         // If the current elements of both lists are equal, keep going.
-        (&Cons(ref x, ~ref next_xs), &Cons(ref y, ~ref next_ys))
+        (&Cons(ref x, box ref next_xs), &Cons(ref y, box ref next_ys))
                 if x == y => eq(next_xs, next_ys),
         // If the current elements are not equal, the lists are not equal.
         _ => false
     }
 }
 
-let xs = Cons('c', ~Cons('a', ~Cons('t', ~Nil)));
-let ys = Cons('c', ~Cons('a', ~Cons('t', ~Nil)));
+let xs = Cons('c', box Cons('a', box Cons('t', box Nil)));
+let ys = Cons('c', box Cons('a', box Cons('t', box Nil)));
 assert!(eq(&xs, &ys));
 ~~~
 
@@ -1321,7 +1323,7 @@ on.
 
 ~~~
 # enum List<T> {
-#     Cons(T, ~List<T>),
+#     Cons(T, Box<List<T>>),
 #     Nil
 # }
 impl<T: Eq> Eq for List<T> {
@@ -1331,7 +1333,7 @@ impl<T: Eq> Eq for List<T> {
             // If we have reached the end of both lists, they are equal.
             (&Nil, &Nil) => true,
             // If the current elements of both lists are equal, keep going.
-            (&Cons(ref x, ~ref next_xs), &Cons(ref y, ~ref next_ys))
+            (&Cons(ref x, box ref next_xs), &Cons(ref y, box ref next_ys))
                     if x == y => next_xs == next_ys,
             // If the current elements are not equal, the lists are not equal.
             _ => false
@@ -1339,8 +1341,8 @@ impl<T: Eq> Eq for List<T> {
     }
 }
 
-let xs = Cons(5, ~Cons(10, ~Nil));
-let ys = Cons(5, ~Cons(10, ~Nil));
+let xs = Cons(5, box Cons(10, box Nil));
+let ys = Cons(5, box Cons(10, box Nil));
 // The methods below are part of the Eq trait,
 // which we implemented on our linked list.
 assert!(xs.eq(&ys));
@@ -1373,7 +1375,7 @@ fn foo() -> (u64, u64, u64, u64, u64, u64) {
     (5, 5, 5, 5, 5, 5)
 }
 
-let x = ~foo(); // allocates a `~` box, and writes the integers directly to it
+let x = box foo(); // allocates a box, and writes the integers directly to it
 ~~~~
 
 Beyond the properties granted by the size, an owned box behaves as a regular
@@ -1384,8 +1386,8 @@ let x = 5; // immutable
 let mut y = 5; // mutable
 y += 2;
 
-let x = ~5; // immutable
-let mut y = ~5; // mutable
+let x = box 5; // immutable
+let mut y = box 5; // mutable
 *y += 2; // the `*` operator is needed to access the contained value
 ~~~~
 
@@ -1413,8 +1415,8 @@ contains a point, but allocated in a different location:
 
 ~~~
 # struct Point { x: f64, y: f64 }
-let on_the_stack :  Point =  Point { x: 3.0, y: 4.0 };
-let owned_box    : ~Point = ~Point { x: 7.0, y: 9.0 };
+let on_the_stack :     Point  =     Point { x: 3.0, y: 4.0 };
+let owned_box    : Box<Point> = box Point { x: 7.0, y: 9.0 };
 ~~~
 
 Suppose we want to write a procedure that computes the distance
@@ -1438,8 +1440,8 @@ Now we can call `compute_distance()` in various ways:
 
 ~~~
 # struct Point{ x: f64, y: f64 };
-# let on_the_stack : Point  =  Point { x: 3.0, y: 4.0 };
-# let owned_box    : ~Point = ~Point { x: 7.0, y: 9.0 };
+# let on_the_stack :     Point  =     Point { x: 3.0, y: 4.0 };
+# let owned_box    : Box<Point> = box Point { x: 7.0, y: 9.0 };
 # fn compute_distance(p1: &Point, p2: &Point) -> f64 { 0.0 }
 compute_distance(&on_the_stack, owned_box);
 ~~~
@@ -1453,7 +1455,7 @@ route to the same data.
 
 In the case of `owned_box`, however, no
 explicit action is necessary. The compiler will automatically convert
-a box `~point` to a reference like
+a box `box point` to a reference like
 `&point`. This is another form of borrowing; in this case, the
 contents of the owned box are being lent out.
 
@@ -1492,7 +1494,7 @@ Rust uses the unary star operator (`*`) to access the contents of a
 box or pointer, similarly to C.
 
 ~~~
-let owned = ~10;
+let owned = box 10;
 let borrowed = &20;
 
 let sum = *owned + *borrowed;
@@ -1503,7 +1505,7 @@ assignments. Such an assignment modifies the value that the pointer
 points to.
 
 ~~~
-let mut owned = ~10;
+let mut owned = box 10;
 
 let mut value = 20;
 let borrowed = &mut value;
@@ -1520,8 +1522,8 @@ can sometimes make code awkward and parenthesis-filled.
 # struct Point { x: f64, y: f64 }
 # enum Shape { Rectangle(Point, Point) }
 # impl Shape { fn area(&self) -> int { 0 } }
-let start = ~Point { x: 10.0, y: 20.0 };
-let end = ~Point { x: (*start).x + 100.0, y: (*start).y + 100.0 };
+let start = box Point { x: 10.0, y: 20.0 };
+let end = box Point { x: (*start).x + 100.0, y: (*start).y + 100.0 };
 let rect = &Rectangle(*start, *end);
 let area = (*rect).area();
 ~~~
@@ -1534,8 +1536,8 @@ dot), so in most cases, explicitly dereferencing the receiver is not necessary.
 # struct Point { x: f64, y: f64 }
 # enum Shape { Rectangle(Point, Point) }
 # impl Shape { fn area(&self) -> int { 0 } }
-let start = ~Point { x: 10.0, y: 20.0 };
-let end = ~Point { x: start.x + 100.0, y: start.y + 100.0 };
+let start = box Point { x: 10.0, y: 20.0 };
+let end = box Point { x: start.x + 100.0, y: start.y + 100.0 };
 let rect = &Rectangle(*start, *end);
 let area = rect.area();
 ~~~
@@ -1546,7 +1548,7 @@ something silly like
 
 ~~~
 # struct Point { x: f64, y: f64 }
-let point = &~Point { x: 10.0, y: 20.0 };
+let point = &box Point { x: 10.0, y: 20.0 };
 println!("{:f}", point.x);
 ~~~
 
@@ -1944,7 +1946,7 @@ impl Shape {
 let s = Circle(Point { x: 1.0, y: 2.0 }, 3.0);
 
 (&s).draw_reference();
-(~s).draw_owned();
+(box s).draw_owned();
 s.draw_value();
 ~~~
 
@@ -1969,7 +1971,7 @@ to a reference.
 // As with typical function arguments, owned pointers
 // are automatically converted to references
 
-(~s).draw_reference();
+(box s).draw_reference();
 
 // Unlike typical function arguments, the self value will
 // automatically be referenced ...
@@ -1979,7 +1981,7 @@ s.draw_reference();
 (& &s).draw_reference();
 
 // ... and dereferenced and borrowed
-(&~s).draw_reference();
+(&box s).draw_reference();
 ~~~
 
 Implementations may also define standalone (sometimes called "static")
@@ -2433,7 +2435,7 @@ an _object_.
 
 ~~~~
 # trait Drawable { fn draw(&self); }
-fn draw_all(shapes: &[~Drawable]) {
+fn draw_all(shapes: &[Box<Drawable>]) {
     for shape in shapes.iter() { shape.draw(); }
 }
 ~~~~
@@ -2448,14 +2450,14 @@ to an object:
 # trait Drawable { fn draw(&self); }
 # fn new_circle() -> Circle { 1 }
 # fn new_rectangle() -> Rectangle { true }
-# fn draw_all(shapes: &[~Drawable]) {}
+# fn draw_all(shapes: &[Box<Drawable>]) {}
 
 impl Drawable for Circle { fn draw(&self) { /* ... */ } }
 impl Drawable for Rectangle { fn draw(&self) { /* ... */ } }
 
-let c: ~Circle = ~new_circle();
-let r: ~Rectangle = ~new_rectangle();
-draw_all([c as ~Drawable, r as ~Drawable]);
+let c: Box<Circle> = box new_circle();
+let r: Box<Rectangle> = box new_rectangle();
+draw_all([c as Box<Drawable>, r as Box<Drawable>]);
 ~~~~
 
 We omit the code for `new_circle` and `new_rectangle`; imagine that
@@ -2464,7 +2466,7 @@ that, like strings and vectors, objects have dynamic size and may
 only be referred to via one of the pointer types.
 Other pointer types work as well.
 Casts to traits may only be done with compatible pointers so,
-for example, an `&Circle` may not be cast to an `~Drawable`.
+for example, an `&Circle` may not be cast to a `Box<Drawable>`.
 
 ~~~
 # type Circle = int; type Rectangle = int;
@@ -2473,7 +2475,7 @@ for example, an `&Circle` may not be cast to an `~Drawable`.
 # fn new_circle() -> int { 1 }
 # fn new_rectangle() -> int { 2 }
 // An owned object
-let owny: ~Drawable = ~new_circle() as ~Drawable;
+let owny: Box<Drawable> = box new_circle() as Box<Drawable>;
 // A borrowed object
 let stacky: &Drawable = &new_circle() as &Drawable;
 ~~~
@@ -2497,7 +2499,7 @@ valid types:
 trait Foo {}
 trait Bar<T> {}
 
-fn sendable_foo(f: ~Foo:Send) { /* ... */ }
+fn sendable_foo(f: Box<Foo:Send>) { /* ... */ }
 fn shareable_bar<T: Share>(b: &Bar<T>: Share) { /* ... */ }
 ~~~
 
diff --git a/src/libarena/lib.rs b/src/libarena/lib.rs
index d80385587da..24e7a65e02a 100644
--- a/src/libarena/lib.rs
+++ b/src/libarena/lib.rs
@@ -29,14 +29,14 @@ extern crate collections;
 use std::cast::{transmute, transmute_mut_lifetime};
 use std::cast;
 use std::cell::{Cell, RefCell};
-use std::mem;
-use std::ptr::read;
 use std::cmp;
-use std::num;
-use std::rc::Rc;
-use std::rt::global_heap;
 use std::intrinsics::{TyDesc, get_tydesc};
 use std::intrinsics;
+use std::mem;
+use std::num;
+use std::ptr::read;
+use std::rc::Rc;
+use std::rt::global_heap;
 
 // The way arena uses arrays is really deeply awful. The arrays are
 // allocated, and have capacities reserved, but the fill for the array
@@ -339,12 +339,12 @@ pub struct TypedArena<T> {
     end: *T,
 
     /// A pointer to the first arena segment.
-    first: Option<~TypedArenaChunk<T>>,
+    first: Option<Box<TypedArenaChunk<T>>>,
 }
 
 struct TypedArenaChunk<T> {
     /// Pointer to the next arena segment.
-    next: Option<~TypedArenaChunk<T>>,
+    next: Option<Box<TypedArenaChunk<T>>>,
 
     /// The number of elements that this chunk can hold.
     capacity: uint,
@@ -354,7 +354,8 @@ struct TypedArenaChunk<T> {
 
 impl<T> TypedArenaChunk<T> {
     #[inline]
-    fn new(next: Option<~TypedArenaChunk<T>>, capacity: uint) -> ~TypedArenaChunk<T> {
+    fn new(next: Option<Box<TypedArenaChunk<T>>>, capacity: uint)
+           -> Box<TypedArenaChunk<T>> {
         let mut size = mem::size_of::<TypedArenaChunk<T>>();
         size = round_up(size, mem::min_align_of::<T>());
         let elem_size = mem::size_of::<T>();
@@ -363,7 +364,7 @@ impl<T> TypedArenaChunk<T> {
 
         let mut chunk = unsafe {
             let chunk = global_heap::exchange_malloc(size);
-            let mut chunk: ~TypedArenaChunk<T> = cast::transmute(chunk);
+            let mut chunk: Box<TypedArenaChunk<T>> = cast::transmute(chunk);
             mem::move_val_init(&mut chunk.next, next);
             chunk
         };
diff --git a/src/libcollections/btree.rs b/src/libcollections/btree.rs
index 30add695646..245040d791c 100644
--- a/src/libcollections/btree.rs
+++ b/src/libcollections/btree.rs
@@ -140,7 +140,8 @@ impl<K: TotalOrd, V> Node<K, V> {
     }
 
     ///Creates a new branch node given a vector of an elements and a pointer to a rightmost child.
-    fn new_branch(vec: Vec<BranchElt<K, V>>, right: ~Node<K, V>) -> Node<K, V> {
+    fn new_branch(vec: Vec<BranchElt<K, V>>, right: Box<Node<K, V>>)
+                  -> Node<K, V> {
         BranchNode(Branch::new(vec, right))
     }
 
@@ -270,7 +271,7 @@ struct Leaf<K, V> {
 //Vector of values with children, plus a rightmost child (greater than all)
 struct Branch<K, V> {
     elts: Vec<BranchElt<K,V>>,
-    rightmost_child: ~Node<K, V>
+    rightmost_child: Box<Node<K, V>>,
 }
 
 
@@ -434,7 +435,8 @@ impl<K: fmt::Show + TotalOrd, V: fmt::Show> fmt::Show for Leaf<K, V> {
 
 impl<K: TotalOrd, V> Branch<K, V> {
     ///Creates a new Branch from a vector of BranchElts and a rightmost child (a node).
-    fn new(vec: Vec<BranchElt<K, V>>, right: ~Node<K, V>) -> Branch<K, V> {
+    fn new(vec: Vec<BranchElt<K, V>>, right: Box<Node<K, V>>)
+           -> Branch<K, V> {
         Branch {
             elts: vec,
             rightmost_child: right
@@ -667,7 +669,7 @@ struct LeafElt<K, V> {
 
 //A BranchElt has a left child in insertion to a key-value pair.
 struct BranchElt<K, V> {
-    left: ~Node<K, V>,
+    left: Box<Node<K, V>>,
     key: K,
     value: V
 }
@@ -719,7 +721,7 @@ impl<K: fmt::Show + TotalOrd, V: fmt::Show> fmt::Show for LeafElt<K, V> {
 
 impl<K: TotalOrd, V> BranchElt<K, V> {
     ///Creates a new BranchElt from a supplied key, value, and left child.
-    fn new(k: K, v: V, n: ~Node<K, V>) -> BranchElt<K, V> {
+    fn new(k: K, v: V, n: Box<Node<K, V>>) -> BranchElt<K, V> {
         BranchElt {
             left: n,
             key: k,
diff --git a/src/libcollections/dlist.rs b/src/libcollections/dlist.rs
index 0f82942d7e7..6763b32afd0 100644
--- a/src/libcollections/dlist.rs
+++ b/src/libcollections/dlist.rs
@@ -15,7 +15,6 @@
 //! DList implements the trait Deque. It should be imported with `use
 //! collections::deque::Deque`.
 
-
 // DList is constructed like a singly-linked list over the field `next`.
 // including the last link being None; each Node owns its `next` field.
 //
@@ -23,10 +22,10 @@
 // the reverse direction.
 
 use std::cast;
-use std::mem::{replace, swap};
-use std::ptr;
 use std::iter::Rev;
 use std::iter;
+use std::mem::{replace, swap};
+use std::ptr;
 
 use deque::Deque;
 
@@ -37,7 +36,7 @@ pub struct DList<T> {
     list_tail: Rawlink<Node<T>>,
 }
 
-type Link<T> = Option<~Node<T>>;
+type Link<T> = Option<Box<Node<T>>>;
 struct Rawlink<T> { p: *mut T }
 
 struct Node<T> {
@@ -118,7 +117,8 @@ impl<T> Node<T> {
 }
 
 /// Set the .prev field on `next`, then return `Some(next)`
-fn link_with_prev<T>(mut next: ~Node<T>, prev: Rawlink<Node<T>>) -> Link<T> {
+fn link_with_prev<T>(mut next: Box<Node<T>>, prev: Rawlink<Node<T>>)
+                  -> Link<T> {
     next.prev = prev;
     Some(next)
 }
@@ -150,7 +150,7 @@ impl<T> Mutable for DList<T> {
 impl<T> DList<T> {
     /// Add a Node first in the list
     #[inline]
-    fn push_front_node(&mut self, mut new_head: ~Node<T>) {
+    fn push_front_node(&mut self, mut new_head: Box<Node<T>>) {
         match self.list_head {
             None => {
                 self.list_tail = Rawlink::some(new_head);
@@ -168,7 +168,7 @@ impl<T> DList<T> {
 
     /// Remove the first Node and return it, or None if the list is empty
     #[inline]
-    fn pop_front_node(&mut self) -> Option<~Node<T>> {
+    fn pop_front_node(&mut self) -> Option<Box<Node<T>>> {
         self.list_head.take().map(|mut front_node| {
             self.length -= 1;
             match front_node.next.take() {
@@ -181,7 +181,7 @@ impl<T> DList<T> {
 
     /// Add a Node last in the list
     #[inline]
-    fn push_back_node(&mut self, mut new_tail: ~Node<T>) {
+    fn push_back_node(&mut self, mut new_tail: Box<Node<T>>) {
         match self.list_tail.resolve() {
             None => return self.push_front_node(new_tail),
             Some(tail) => {
@@ -194,7 +194,7 @@ impl<T> DList<T> {
 
     /// Remove the last Node and return it, or None if the list is empty
     #[inline]
-    fn pop_back_node(&mut self) -> Option<~Node<T>> {
+    fn pop_back_node(&mut self) -> Option<Box<Node<T>>> {
         self.list_tail.resolve().map_or(None, |tail| {
             self.length -= 1;
             self.list_tail = tail.prev;
@@ -245,7 +245,7 @@ impl<T> Deque<T> for DList<T> {
     ///
     /// O(1)
     fn pop_front(&mut self) -> Option<T> {
-        self.pop_front_node().map(|~Node{value, ..}| value)
+        self.pop_front_node().map(|box Node{value, ..}| value)
     }
 
     /// Add an element last in the list
@@ -259,7 +259,7 @@ impl<T> Deque<T> for DList<T> {
     ///
     /// O(1)
     fn pop_back(&mut self) -> Option<T> {
-        self.pop_back_node().map(|~Node{value, ..}| value)
+        self.pop_back_node().map(|box Node{value, ..}| value)
     }
 }
 
@@ -432,7 +432,7 @@ impl<T> Drop for DList<T> {
             match tail.resolve() {
                 None => break,
                 Some(prev) => {
-                    prev.next.take(); // release ~Node<T>
+                    prev.next.take(); // release Box<Node<T>>
                     tail = prev.prev;
                 }
             }
@@ -531,7 +531,7 @@ pub trait ListInsertion<A> {
 
 // private methods for MutItems
 impl<'a, A> MutItems<'a, A> {
-    fn insert_next_node(&mut self, mut ins_node: ~Node<A>) {
+    fn insert_next_node(&mut self, mut ins_node: Box<Node<A>>) {
         // Insert before `self.head` so that it is between the
         // previously yielded element and self.head.
         //
@@ -671,24 +671,24 @@ mod tests {
 
     #[test]
     fn test_basic() {
-        let mut m: DList<~int> = DList::new();
+        let mut m: DList<Box<int>> = DList::new();
         assert_eq!(m.pop_front(), None);
         assert_eq!(m.pop_back(), None);
         assert_eq!(m.pop_front(), None);
         m.push_front(box 1);
-        assert_eq!(m.pop_front(), Some(~1));
+        assert_eq!(m.pop_front(), Some(box 1));
         m.push_back(box 2);
         m.push_back(box 3);
         assert_eq!(m.len(), 2);
-        assert_eq!(m.pop_front(), Some(~2));
-        assert_eq!(m.pop_front(), Some(~3));
+        assert_eq!(m.pop_front(), Some(box 2));
+        assert_eq!(m.pop_front(), Some(box 3));
         assert_eq!(m.len(), 0);
         assert_eq!(m.pop_front(), None);
         m.push_back(box 1);
         m.push_back(box 3);
         m.push_back(box 5);
         m.push_back(box 7);
-        assert_eq!(m.pop_front(), Some(~1));
+        assert_eq!(m.pop_front(), Some(box 1));
 
         let mut n = DList::new();
         n.push_front(2);
diff --git a/src/libcollections/lru_cache.rs b/src/libcollections/lru_cache.rs
index 22876bf3975..13297df902a 100644
--- a/src/libcollections/lru_cache.rs
+++ b/src/libcollections/lru_cache.rs
@@ -57,7 +57,7 @@ struct LruEntry<K, V> {
 
 /// An LRU Cache.
 pub struct LruCache<K, V> {
-    map: HashMap<KeyRef<K>, ~LruEntry<K, V>>,
+    map: HashMap<KeyRef<K>, Box<LruEntry<K, V>>>,
     max_size: uint,
     head: *mut LruEntry<K, V>,
 }
@@ -241,9 +241,9 @@ impl<K: Hash + TotalEq, V> Mutable for LruCache<K, V> {
 impl<K, V> Drop for LruCache<K, V> {
     fn drop(&mut self) {
         unsafe {
-            let node: ~LruEntry<K, V> = cast::transmute(self.head);
+            let node: Box<LruEntry<K, V>> = cast::transmute(self.head);
             // Prevent compiler from trying to drop the un-initialized field in the sigil node.
-            let ~LruEntry { key: k, value: v, .. } = node;
+            let box LruEntry { key: k, value: v, .. } = node;
             cast::forget(k);
             cast::forget(v);
         }
diff --git a/src/libcollections/priority_queue.rs b/src/libcollections/priority_queue.rs
index e37e2a6f234..f9f4945efc7 100644
--- a/src/libcollections/priority_queue.rs
+++ b/src/libcollections/priority_queue.rs
@@ -270,24 +270,24 @@ mod tests {
 
     #[test]
     fn test_push_unique() {
-        let mut heap = PriorityQueue::from_vec(vec!(~2, ~4, ~9));
+        let mut heap = PriorityQueue::from_vec(vec!(box 2, box 4, box 9));
         assert_eq!(heap.len(), 3);
-        assert!(*heap.top() == ~9);
+        assert!(*heap.top() == box 9);
         heap.push(box 11);
         assert_eq!(heap.len(), 4);
-        assert!(*heap.top() == ~11);
+        assert!(*heap.top() == box 11);
         heap.push(box 5);
         assert_eq!(heap.len(), 5);
-        assert!(*heap.top() == ~11);
+        assert!(*heap.top() == box 11);
         heap.push(box 27);
         assert_eq!(heap.len(), 6);
-        assert!(*heap.top() == ~27);
+        assert!(*heap.top() == box 27);
         heap.push(box 3);
         assert_eq!(heap.len(), 7);
-        assert!(*heap.top() == ~27);
+        assert!(*heap.top() == box 27);
         heap.push(box 103);
         assert_eq!(heap.len(), 8);
-        assert!(*heap.top() == ~103);
+        assert!(*heap.top() == box 103);
     }
 
     #[test]
diff --git a/src/libcollections/smallintmap.rs b/src/libcollections/smallintmap.rs
index e236e58b08d..fb02ddd6224 100644
--- a/src/libcollections/smallintmap.rs
+++ b/src/libcollections/smallintmap.rs
@@ -465,7 +465,7 @@ mod test_map {
             assert!(!called);
             called = true;
             assert_eq!(k, 1);
-            assert_eq!(v, ~2);
+            assert_eq!(v, box 2);
         }
         assert!(called);
         m.insert(2, box 1);
diff --git a/src/libcollections/treemap.rs b/src/libcollections/treemap.rs
index 3f993fc64a4..eff20d30906 100644
--- a/src/libcollections/treemap.rs
+++ b/src/libcollections/treemap.rs
@@ -36,7 +36,7 @@ use std::ptr;
 #[allow(missing_doc)]
 #[deriving(Clone)]
 pub struct TreeMap<K, V> {
-    root: Option<~TreeNode<K, V>>,
+    root: Option<Box<TreeNode<K, V>>>,
     length: uint
 }
 
@@ -79,7 +79,7 @@ impl<K: TotalOrd, V> Mutable for TreeMap<K, V> {
 
 impl<K: TotalOrd, V> Map<K, V> for TreeMap<K, V> {
     fn find<'a>(&'a self, key: &K) -> Option<&'a V> {
-        let mut current: &'a Option<~TreeNode<K, V>> = &self.root;
+        let mut current: &'a Option<Box<TreeNode<K, V>>> = &self.root;
         loop {
             match *current {
               Some(ref r) => {
@@ -157,7 +157,7 @@ impl<K: TotalOrd, V> TreeMap<K, V> {
         let TreeMap { root: root, length: length } = self;
         let stk = match root {
             None => vec!(),
-            Some(~tn) => vec!(tn)
+            Some(box tn) => vec!(tn)
         };
         MoveEntries {
             stack: stk,
@@ -317,7 +317,7 @@ macro_rules! define_iterator {
     ($name:ident,
      $rev_name:ident,
 
-     // the function to go from &m Option<~TreeNode> to *m TreeNode
+     // the function to go from &m Option<Box<TreeNode>> to *m TreeNode
      deref = $deref:ident,
 
      // see comment on `addr!`, this is just an optional `mut`, but
@@ -441,7 +441,7 @@ define_iterator! {
     addr_mut = mut
 }
 
-fn deref<'a, K, V>(node: &'a Option<~TreeNode<K, V>>) -> *TreeNode<K, V> {
+fn deref<'a, K, V>(node: &'a Option<Box<TreeNode<K, V>>>) -> *TreeNode<K, V> {
     match *node {
         Some(ref n) => {
             let n: &TreeNode<K, V> = *n;
@@ -451,7 +451,8 @@ fn deref<'a, K, V>(node: &'a Option<~TreeNode<K, V>>) -> *TreeNode<K, V> {
     }
 }
 
-fn mut_deref<K, V>(x: &mut Option<~TreeNode<K, V>>) -> *mut TreeNode<K, V> {
+fn mut_deref<K, V>(x: &mut Option<Box<TreeNode<K, V>>>)
+             -> *mut TreeNode<K, V> {
     match *x {
         Some(ref mut n) => {
             let n: &mut TreeNode<K, V> = *n;
@@ -482,7 +483,7 @@ impl<K, V> Iterator<(K, V)> for MoveEntries<K,V> {
             } = self.stack.pop().unwrap();
 
             match left {
-                Some(~left) => {
+                Some(box left) => {
                     let n = TreeNode {
                         key: key,
                         value: value,
@@ -495,7 +496,7 @@ impl<K, V> Iterator<(K, V)> for MoveEntries<K,V> {
                 }
                 None => {
                     match right {
-                        Some(~right) => self.stack.push(right),
+                        Some(box right) => self.stack.push(right),
                         None => ()
                     }
                     self.remaining -= 1;
@@ -759,8 +760,8 @@ impl<'a, T: TotalOrd> Iterator<&'a T> for UnionItems<'a, T> {
 struct TreeNode<K, V> {
     key: K,
     value: V,
-    left: Option<~TreeNode<K, V>>,
-    right: Option<~TreeNode<K, V>>,
+    left: Option<Box<TreeNode<K, V>>>,
+    right: Option<Box<TreeNode<K, V>>>,
     level: uint
 }
 
@@ -773,7 +774,7 @@ impl<K: TotalOrd, V> TreeNode<K, V> {
 }
 
 // Remove left horizontal link by rotating right
-fn skew<K: TotalOrd, V>(node: &mut ~TreeNode<K, V>) {
+fn skew<K: TotalOrd, V>(node: &mut Box<TreeNode<K, V>>) {
     if node.left.as_ref().map_or(false, |x| x.level == node.level) {
         let mut save = node.left.take_unwrap();
         swap(&mut node.left, &mut save.right); // save.right now None
@@ -784,7 +785,7 @@ fn skew<K: TotalOrd, V>(node: &mut ~TreeNode<K, V>) {
 
 // Remove dual horizontal link by rotating left and increasing level of
 // the parent
-fn split<K: TotalOrd, V>(node: &mut ~TreeNode<K, V>) {
+fn split<K: TotalOrd, V>(node: &mut Box<TreeNode<K, V>>) {
     if node.right.as_ref().map_or(false,
       |x| x.right.as_ref().map_or(false, |y| y.level == node.level)) {
         let mut save = node.right.take_unwrap();
@@ -795,7 +796,7 @@ fn split<K: TotalOrd, V>(node: &mut ~TreeNode<K, V>) {
     }
 }
 
-fn find_mut<'r, K: TotalOrd, V>(node: &'r mut Option<~TreeNode<K, V>>,
+fn find_mut<'r, K: TotalOrd, V>(node: &'r mut Option<Box<TreeNode<K, V>>>,
                                 key: &K)
                              -> Option<&'r mut V> {
     match *node {
@@ -810,7 +811,7 @@ fn find_mut<'r, K: TotalOrd, V>(node: &'r mut Option<~TreeNode<K, V>>,
     }
 }
 
-fn insert<K: TotalOrd, V>(node: &mut Option<~TreeNode<K, V>>,
+fn insert<K: TotalOrd, V>(node: &mut Option<Box<TreeNode<K, V>>>,
                           key: K, value: V) -> Option<V> {
     match *node {
       Some(ref mut save) => {
@@ -840,10 +841,10 @@ fn insert<K: TotalOrd, V>(node: &mut Option<~TreeNode<K, V>>,
     }
 }
 
-fn remove<K: TotalOrd, V>(node: &mut Option<~TreeNode<K, V>>,
+fn remove<K: TotalOrd, V>(node: &mut Option<Box<TreeNode<K, V>>>,
                           key: &K) -> Option<V> {
-    fn heir_swap<K: TotalOrd, V>(node: &mut ~TreeNode<K, V>,
-                                 child: &mut Option<~TreeNode<K, V>>) {
+    fn heir_swap<K: TotalOrd, V>(node: &mut Box<TreeNode<K, V>>,
+                                 child: &mut Option<Box<TreeNode<K, V>>>) {
         // *could* be done without recursion, but it won't borrow check
         for x in child.mut_iter() {
             if x.right.is_some() {
@@ -877,13 +878,13 @@ fn remove<K: TotalOrd, V>(node: &mut Option<~TreeNode<K, V>>,
                     (remove(&mut save.left, key), true)
                 } else {
                     let new = save.left.take_unwrap();
-                    let ~TreeNode{value, ..} = replace(save, new);
+                    let box TreeNode{value, ..} = replace(save, new);
                     *save = save.left.take_unwrap();
                     (Some(value), true)
                 }
             } else if save.right.is_some() {
                 let new = save.right.take_unwrap();
-                let ~TreeNode{value, ..} = replace(save, new);
+                let box TreeNode{value, ..} = replace(save, new);
                 (Some(value), true)
             } else {
                 (None, false)
@@ -919,7 +920,7 @@ fn remove<K: TotalOrd, V>(node: &mut Option<~TreeNode<K, V>>,
       }
     }
     return match node.take() {
-        Some(~TreeNode{value, ..}) => Some(value), None => fail!()
+        Some(box TreeNode{value, ..}) => Some(value), None => fail!()
     };
 }
 
@@ -959,7 +960,6 @@ impl<T: TotalOrd> Extendable<T> for TreeSet<T> {
 
 #[cfg(test)]
 mod test_treemap {
-
     use super::{TreeMap, TreeNode};
 
     use rand::Rng;
@@ -1053,8 +1053,8 @@ mod test_treemap {
         }
     }
 
-    fn check_left<K: TotalOrd, V>(node: &Option<~TreeNode<K, V>>,
-                                  parent: &~TreeNode<K, V>) {
+    fn check_left<K: TotalOrd, V>(node: &Option<Box<TreeNode<K, V>>>,
+                                  parent: &Box<TreeNode<K, V>>) {
         match *node {
           Some(ref r) => {
             assert_eq!(r.key.cmp(&parent.key), Less);
@@ -1066,8 +1066,8 @@ mod test_treemap {
         }
     }
 
-    fn check_right<K: TotalOrd, V>(node: &Option<~TreeNode<K, V>>,
-                                   parent: &~TreeNode<K, V>,
+    fn check_right<K: TotalOrd, V>(node: &Option<Box<TreeNode<K, V>>>,
+                                   parent: &Box<TreeNode<K, V>>,
                                    parent_red: bool) {
         match *node {
           Some(ref r) => {
diff --git a/src/libcollections/trie.rs b/src/libcollections/trie.rs
index 1bff058d6f5..ce69ba00787 100644
--- a/src/libcollections/trie.rs
+++ b/src/libcollections/trie.rs
@@ -10,11 +10,11 @@
 
 //! Ordered containers with integer keys, implemented as radix tries (`TrieSet` and `TrieMap` types)
 
-use std::mem;
-use std::uint;
 use std::mem::init;
-use std::slice;
+use std::mem;
 use std::slice::{Items, MutItems};
+use std::slice;
+use std::uint;
 
 // FIXME: #5244: need to manually update the TrieNode constructor
 static SHIFT: uint = 4;
@@ -23,7 +23,7 @@ static MASK: uint = SIZE - 1;
 static NUM_CHUNKS: uint = uint::BITS / SHIFT;
 
 enum Child<T> {
-    Internal(~TrieNode<T>),
+    Internal(Box<TrieNode<T>>),
     External(uint, T),
     Nothing
 }
diff --git a/src/libfourcc/lib.rs b/src/libfourcc/lib.rs
index 04fa139168f..34ff35a3ad6 100644
--- a/src/libfourcc/lib.rs
+++ b/src/libfourcc/lib.rs
@@ -66,14 +66,15 @@ use syntax::parse::token::InternedString;
 #[macro_registrar]
 pub fn macro_registrar(register: |Name, SyntaxExtension|) {
     register(token::intern("fourcc"),
-        NormalTT(~BasicMacroExpander {
+        NormalTT(box BasicMacroExpander {
             expander: expand_syntax_ext,
             span: None,
         },
         None));
 }
 
-pub fn expand_syntax_ext(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) -> ~base::MacResult {
+pub fn expand_syntax_ext(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
+                         -> Box<base::MacResult> {
     let (expr, endian) = parse_tts(cx, tts);
 
     let little = match endian {
diff --git a/src/libgraphviz/maybe_owned_vec.rs b/src/libgraphviz/maybe_owned_vec.rs
index 649bad702ea..817f6348361 100644
--- a/src/libgraphviz/maybe_owned_vec.rs
+++ b/src/libgraphviz/maybe_owned_vec.rs
@@ -18,7 +18,7 @@ use std::slice;
 
 // Note 2: Once Dynamically Sized Types (DST) lands, it might be
 // reasonable to replace this with something like `enum MaybeOwned<'a,
-// Sized? U>{ Owned(~U), Borrowed(&'a U) }`; and then `U` could be
+// Sized? U>{ Owned(Box<U>), Borrowed(&'a U) }`; and then `U` could be
 // instantiated with `[T]` or `str`, etc.  Of course, that would imply
 // removing the `Growable` variant, which relates to note 1 above.
 // Alternatively, we might add `MaybeOwned` for the general case but
diff --git a/src/libgreen/basic.rs b/src/libgreen/basic.rs
index 4da0214c27c..eba15e6e6d5 100644
--- a/src/libgreen/basic.rs
+++ b/src/libgreen/basic.rs
@@ -17,19 +17,19 @@
 
 use std::cast;
 use std::mem::replace;
-use std::rt::rtio::{EventLoop, IoFactory, RemoteCallback, PausableIdleCallback,
-                    Callback};
+use std::rt::rtio::{EventLoop, IoFactory, RemoteCallback};
+use std::rt::rtio::{PausableIdleCallback, Callback};
 use std::unstable::sync::Exclusive;
 
 /// This is the only exported function from this module.
-pub fn event_loop() -> ~EventLoop:Send {
-    box BasicLoop::new() as ~EventLoop:Send
+pub fn event_loop() -> Box<EventLoop:Send> {
+    box BasicLoop::new() as Box<EventLoop:Send>
 }
 
 struct BasicLoop {
     work: Vec<proc():Send>,             // pending work
     idle: Option<*mut BasicPausable>, // only one is allowed
-    remotes: Vec<(uint, ~Callback:Send)>,
+    remotes: Vec<(uint, Box<Callback:Send>)>,
     next_remote: uint,
     messages: Exclusive<Vec<Message>>,
 }
@@ -140,23 +140,24 @@ impl EventLoop for BasicLoop {
     }
 
     // FIXME: Seems like a really weird requirement to have an event loop provide.
-    fn pausable_idle_callback(&mut self, cb: ~Callback:Send)
-        -> ~PausableIdleCallback:Send
-    {
+    fn pausable_idle_callback(&mut self, cb: Box<Callback:Send>)
+                              -> Box<PausableIdleCallback:Send> {
         let callback = box BasicPausable::new(self, cb);
         rtassert!(self.idle.is_none());
         unsafe {
             let cb_ptr: &*mut BasicPausable = cast::transmute(&callback);
             self.idle = Some(*cb_ptr);
         }
-        callback as ~PausableIdleCallback:Send
+        callback as Box<PausableIdleCallback:Send>
     }
 
-    fn remote_callback(&mut self, f: ~Callback:Send) -> ~RemoteCallback:Send {
+    fn remote_callback(&mut self, f: Box<Callback:Send>)
+                       -> Box<RemoteCallback:Send> {
         let id = self.next_remote;
         self.next_remote += 1;
         self.remotes.push((id, f));
-        box BasicRemote::new(self.messages.clone(), id) as ~RemoteCallback:Send
+        box BasicRemote::new(self.messages.clone(), id) as
+            Box<RemoteCallback:Send>
     }
 
     fn io<'a>(&'a mut self) -> Option<&'a mut IoFactory> { None }
@@ -197,12 +198,12 @@ impl Drop for BasicRemote {
 
 struct BasicPausable {
     eloop: *mut BasicLoop,
-    work: ~Callback:Send,
+    work: Box<Callback:Send>,
     active: bool,
 }
 
 impl BasicPausable {
-    fn new(eloop: &mut BasicLoop, cb: ~Callback:Send) -> BasicPausable {
+    fn new(eloop: &mut BasicLoop, cb: Box<Callback:Send>) -> BasicPausable {
         BasicPausable {
             active: false,
             work: cb,
diff --git a/src/libgreen/context.rs b/src/libgreen/context.rs
index c30a93c2323..e5dd9c92358 100644
--- a/src/libgreen/context.rs
+++ b/src/libgreen/context.rs
@@ -8,21 +8,21 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use stack::Stack;
 use std::uint;
 use std::cast::{transmute, transmute_mut_unsafe};
-use stack::Stack;
 use std::rt::stack;
 use std::raw;
 
 // FIXME #7761: Registers is boxed so that it is 16-byte aligned, for storing
 // SSE regs.  It would be marginally better not to do this. In C++ we
 // use an attribute on a struct.
-// FIXME #7761: It would be nice to define regs as `~Option<Registers>` since
-// the registers are sometimes empty, but the discriminant would
+// FIXME #7761: It would be nice to define regs as `Box<Option<Registers>>`
+// since the registers are sometimes empty, but the discriminant would
 // then misalign the regs again.
 pub struct Context {
     /// Hold the registers while the task or scheduler is suspended
-    regs: ~Registers,
+    regs: Box<Registers>,
     /// Lower bound and upper bound for the stack
     stack_bounds: Option<(uint, uint)>,
 }
@@ -87,10 +87,10 @@ impl Context {
     pub fn swap(out_context: &mut Context, in_context: &Context) {
         rtdebug!("swapping contexts");
         let out_regs: &mut Registers = match out_context {
-            &Context { regs: ~ref mut r, .. } => r
+            &Context { regs: box ref mut r, .. } => r
         };
         let in_regs: &Registers = match in_context {
-            &Context { regs: ~ref r, .. } => r
+            &Context { regs: box ref r, .. } => r
         };
 
         rtdebug!("noting the stack limit and doing raw swap");
@@ -151,7 +151,7 @@ struct Registers {
 }
 
 #[cfg(target_arch = "x86")]
-fn new_regs() -> ~Registers {
+fn new_regs() -> Box<Registers> {
     box Registers {
         eax: 0, ebx: 0, ecx: 0, edx: 0,
         ebp: 0, esi: 0, edi: 0, esp: 0,
@@ -190,9 +190,9 @@ type Registers = [uint, ..34];
 type Registers = [uint, ..22];
 
 #[cfg(windows, target_arch = "x86_64")]
-fn new_regs() -> ~Registers { box [0, .. 34] }
+fn new_regs() -> Box<Registers> { box [0, .. 34] }
 #[cfg(not(windows), target_arch = "x86_64")]
-fn new_regs() -> ~Registers { box {let v = [0, .. 22]; v} }
+fn new_regs() -> Box<Registers> { box {let v = [0, .. 22]; v} }
 
 #[cfg(target_arch = "x86_64")]
 fn initialize_call_frame(regs: &mut Registers, fptr: InitFn, arg: uint,
@@ -241,7 +241,7 @@ fn initialize_call_frame(regs: &mut Registers, fptr: InitFn, arg: uint,
 type Registers = [uint, ..32];
 
 #[cfg(target_arch = "arm")]
-fn new_regs() -> ~Registers { box {[0, .. 32]} }
+fn new_regs() -> Box<Registers> { box {[0, .. 32]} }
 
 #[cfg(target_arch = "arm")]
 fn initialize_call_frame(regs: &mut Registers, fptr: InitFn, arg: uint,
@@ -270,7 +270,7 @@ fn initialize_call_frame(regs: &mut Registers, fptr: InitFn, arg: uint,
 type Registers = [uint, ..32];
 
 #[cfg(target_arch = "mips")]
-fn new_regs() -> ~Registers { box [0, .. 32] }
+fn new_regs() -> Box<Registers> { box [0, .. 32] }
 
 #[cfg(target_arch = "mips")]
 fn initialize_call_frame(regs: &mut Registers, fptr: InitFn, arg: uint,
diff --git a/src/libgreen/lib.rs b/src/libgreen/lib.rs
index f86743d10c7..cd598346fc3 100644
--- a/src/libgreen/lib.rs
+++ b/src/libgreen/lib.rs
@@ -288,7 +288,7 @@ macro_rules! green_start( ($f:ident) => (
 /// The return value is used as the process return code. 0 on success, 101 on
 /// error.
 pub fn start(argc: int, argv: **u8,
-             event_loop_factory: fn() -> ~rtio::EventLoop:Send,
+             event_loop_factory: fn() -> Box<rtio::EventLoop:Send>,
              main: proc():Send) -> int {
     rt::init(argc, argv);
     let mut main = Some(main);
@@ -309,7 +309,7 @@ pub fn start(argc: int, argv: **u8,
 ///
 /// This function will not return until all schedulers in the associated pool
 /// have returned.
-pub fn run(event_loop_factory: fn() -> ~rtio::EventLoop:Send,
+pub fn run(event_loop_factory: fn() -> Box<rtio::EventLoop:Send>,
            main: proc():Send) -> int {
     // Create a scheduler pool and spawn the main task into this pool. We will
     // get notified over a channel when the main task exits.
@@ -340,7 +340,7 @@ pub struct PoolConfig {
     pub threads: uint,
     /// A factory function used to create new event loops. If this is not
     /// specified then the default event loop factory is used.
-    pub event_loop_factory: fn() -> ~rtio::EventLoop:Send,
+    pub event_loop_factory: fn() -> Box<rtio::EventLoop:Send>,
 }
 
 impl PoolConfig {
@@ -360,12 +360,12 @@ pub struct SchedPool {
     id: uint,
     threads: Vec<Thread<()>>,
     handles: Vec<SchedHandle>,
-    stealers: Vec<deque::Stealer<~task::GreenTask>>,
+    stealers: Vec<deque::Stealer<Box<task::GreenTask>>>,
     next_friend: uint,
     stack_pool: StackPool,
-    deque_pool: deque::BufferPool<~task::GreenTask>,
+    deque_pool: deque::BufferPool<Box<task::GreenTask>>,
     sleepers: SleeperList,
-    factory: fn() -> ~rtio::EventLoop:Send,
+    factory: fn() -> Box<rtio::EventLoop:Send>,
     task_state: TaskState,
     tasks_done: Receiver<()>,
 }
@@ -445,7 +445,7 @@ impl SchedPool {
     /// This is useful to create a task which can then be sent to a specific
     /// scheduler created by `spawn_sched` (and possibly pin it to that
     /// scheduler).
-    pub fn task(&mut self, opts: TaskOpts, f: proc():Send) -> ~GreenTask {
+    pub fn task(&mut self, opts: TaskOpts, f: proc():Send) -> Box<GreenTask> {
         GreenTask::configure(&mut self.stack_pool, opts, f)
     }
 
diff --git a/src/libgreen/sched.rs b/src/libgreen/sched.rs
index c323dbb92d7..301198a0676 100644
--- a/src/libgreen/sched.rs
+++ b/src/libgreen/sched.rs
@@ -46,10 +46,10 @@ pub struct Scheduler {
     /// inside this pool of schedulers
     pub task_state: TaskState,
     /// There are N work queues, one per scheduler.
-    work_queue: deque::Worker<~GreenTask>,
+    work_queue: deque::Worker<Box<GreenTask>>,
     /// Work queues for the other schedulers. These are created by
     /// cloning the core work queues.
-    work_queues: Vec<deque::Stealer<~GreenTask>>,
+    work_queues: Vec<deque::Stealer<Box<GreenTask>>>,
     /// The queue of incoming messages from other schedulers.
     /// These are enqueued by SchedHandles after which a remote callback
     /// is triggered to handle the message.
@@ -71,7 +71,7 @@ pub struct Scheduler {
     no_sleep: bool,
     /// The scheduler runs on a special task. When it is not running
     /// it is stored here instead of the work queue.
-    sched_task: Option<~GreenTask>,
+    sched_task: Option<Box<GreenTask>>,
     /// An action performed after a context switch on behalf of the
     /// code running before the context switch
     cleanup_job: Option<CleanupJob>,
@@ -83,7 +83,7 @@ pub struct Scheduler {
     /// A fast XorShift rng for scheduler use
     rng: XorShiftRng,
     /// A togglable idle callback
-    idle_callback: Option<~PausableIdleCallback:Send>,
+    idle_callback: Option<Box<PausableIdleCallback:Send>>,
     /// A countdown that starts at a random value and is decremented
     /// every time a yield check is performed. When it hits 0 a task
     /// will yield.
@@ -100,7 +100,7 @@ pub struct Scheduler {
     //      destroyed before it's actually destroyed.
 
     /// The event loop used to drive the scheduler and perform I/O
-    pub event_loop: ~EventLoop:Send,
+    pub event_loop: Box<EventLoop:Send>,
 }
 
 /// An indication of how hard to work on a given operation, the difference
@@ -123,9 +123,9 @@ impl Scheduler {
     // * Initialization Functions
 
     pub fn new(pool_id: uint,
-               event_loop: ~EventLoop:Send,
-               work_queue: deque::Worker<~GreenTask>,
-               work_queues: Vec<deque::Stealer<~GreenTask>>,
+               event_loop: Box<EventLoop:Send>,
+               work_queue: deque::Worker<Box<GreenTask>>,
+               work_queues: Vec<deque::Stealer<Box<GreenTask>>>,
                sleeper_list: SleeperList,
                state: TaskState)
         -> Scheduler {
@@ -136,9 +136,9 @@ impl Scheduler {
     }
 
     pub fn new_special(pool_id: uint,
-                       event_loop: ~EventLoop:Send,
-                       work_queue: deque::Worker<~GreenTask>,
-                       work_queues: Vec<deque::Stealer<~GreenTask>>,
+                       event_loop: Box<EventLoop:Send>,
+                       work_queue: deque::Worker<Box<GreenTask>>,
+                       work_queues: Vec<deque::Stealer<Box<GreenTask>>>,
                        sleeper_list: SleeperList,
                        run_anything: bool,
                        friend: Option<SchedHandle>,
@@ -183,7 +183,7 @@ impl Scheduler {
     pub fn bootstrap(mut ~self) {
 
         // Build an Idle callback.
-        let cb = box SchedRunner as ~Callback:Send;
+        let cb = box SchedRunner as Box<Callback:Send>;
         self.idle_callback = Some(self.event_loop.pausable_idle_callback(cb));
 
         // Create a task for the scheduler with an empty context.
@@ -224,14 +224,14 @@ impl Scheduler {
 
     // This does not return a scheduler, as the scheduler is placed
     // inside the task.
-    pub fn run(mut ~self, stask: ~GreenTask) -> ~GreenTask {
+    pub fn run(mut ~self, stask: Box<GreenTask>) -> Box<GreenTask> {
 
         // This is unsafe because we need to place the scheduler, with
         // the event_loop inside, inside our task. But we still need a
         // mutable reference to the event_loop to give it the "run"
         // command.
         unsafe {
-            let event_loop: *mut ~EventLoop:Send = &mut self.event_loop;
+            let event_loop: *mut Box<EventLoop:Send> = &mut self.event_loop;
             // Our scheduler must be in the task before the event loop
             // is started.
             stask.put_with_sched(self);
@@ -271,7 +271,7 @@ impl Scheduler {
     // If we try really hard to do some work, but no work is available to be
     // done, then we fall back to epoll() to block this thread waiting for more
     // work (instead of busy waiting).
-    fn run_sched_once(mut ~self, stask: ~GreenTask) {
+    fn run_sched_once(mut ~self, stask: Box<GreenTask>) {
         // Make sure that we're not lying in that the `stask` argument is indeed
         // the scheduler task for this scheduler.
         assert!(self.sched_task.is_none());
@@ -349,9 +349,9 @@ impl Scheduler {
     // returns the still-available scheduler. At this point all
     // message-handling will count as a turn of work, and as a result
     // return None.
-    fn interpret_message_queue(mut ~self, stask: ~GreenTask,
+    fn interpret_message_queue(mut ~self, stask: Box<GreenTask>,
                                effort: EffortLevel)
-            -> (~Scheduler, ~GreenTask, bool)
+            -> (Box<Scheduler>, Box<GreenTask>, bool)
     {
 
         let msg = if effort == DontTryTooHard {
@@ -432,8 +432,8 @@ impl Scheduler {
         }
     }
 
-    fn do_work(mut ~self,
-               stask: ~GreenTask) -> (~Scheduler, ~GreenTask, bool) {
+    fn do_work(mut ~self, stask: Box<GreenTask>)
+               -> (Box<Scheduler>, Box<GreenTask>, bool) {
         rtdebug!("scheduler calling do work");
         match self.find_work() {
             Some(task) => {
@@ -459,7 +459,7 @@ impl Scheduler {
     // First step in the process is to find a task. This function does
     // that by first checking the local queue, and if there is no work
     // there, trying to steal from the remote work queues.
-    fn find_work(&mut self) -> Option<~GreenTask> {
+    fn find_work(&mut self) -> Option<Box<GreenTask>> {
         rtdebug!("scheduler looking for work");
         if !self.steal_for_yield {
             match self.work_queue.pop() {
@@ -497,7 +497,7 @@ impl Scheduler {
     // Try stealing from all queues the scheduler knows about. This
     // naive implementation can steal from our own queue or from other
     // special schedulers.
-    fn try_steals(&mut self) -> Option<~GreenTask> {
+    fn try_steals(&mut self) -> Option<Box<GreenTask>> {
         let work_queues = &mut self.work_queues;
         let len = work_queues.len();
         let start_index = self.rng.gen_range(0, len);
@@ -517,9 +517,11 @@ impl Scheduler {
     // * Task Routing Functions - Make sure tasks send up in the right
     // place.
 
-    fn process_task(mut ~self, cur: ~GreenTask,
-                    mut next: ~GreenTask,
-                    schedule_fn: SchedulingFn) -> (~Scheduler, ~GreenTask) {
+    fn process_task(mut ~self,
+                    cur: Box<GreenTask>,
+                    mut next: Box<GreenTask>,
+                    schedule_fn: SchedulingFn)
+                    -> (Box<Scheduler>, Box<GreenTask>) {
         rtdebug!("processing a task");
 
         match next.take_unwrap_home() {
@@ -549,7 +551,7 @@ impl Scheduler {
         }
     }
 
-    fn send_task_home(task: ~GreenTask) {
+    fn send_task_home(task: Box<GreenTask>) {
         let mut task = task;
         match task.take_unwrap_home() {
             HomeSched(mut home_handle) => home_handle.send(PinnedTask(task)),
@@ -559,7 +561,7 @@ impl Scheduler {
 
     /// Take a non-homed task we aren't allowed to run here and send
     /// it to the designated friend scheduler to execute.
-    fn send_to_friend(&mut self, task: ~GreenTask) {
+    fn send_to_friend(&mut self, task: Box<GreenTask>) {
         rtdebug!("sending a task to friend");
         match self.friend_handle {
             Some(ref mut handle) => {
@@ -576,7 +578,7 @@ impl Scheduler {
     /// Pushes the task onto the work stealing queue and tells the
     /// event loop to run it later. Always use this instead of pushing
     /// to the work queue directly.
-    pub fn enqueue_task(&mut self, task: ~GreenTask) {
+    pub fn enqueue_task(&mut self, task: Box<GreenTask>) {
 
         // We push the task onto our local queue clone.
         assert!(!task.is_sched());
@@ -609,9 +611,10 @@ impl Scheduler {
     // old task as inputs.
 
     pub fn change_task_context(mut ~self,
-                               current_task: ~GreenTask,
-                               mut next_task: ~GreenTask,
-                               f: |&mut Scheduler, ~GreenTask|) -> ~GreenTask {
+                               current_task: Box<GreenTask>,
+                               mut next_task: Box<GreenTask>,
+                               f: |&mut Scheduler, Box<GreenTask>|)
+                               -> Box<GreenTask> {
         let f_opaque = ClosureConverter::from_fn(f);
 
         let current_task_dupe = &*current_task as *GreenTask;
@@ -655,7 +658,7 @@ impl Scheduler {
         // When the context swaps back to this task we immediately
         // run the cleanup job, as expected by the previously called
         // swap_contexts function.
-        let mut current_task: ~GreenTask = unsafe {
+        let mut current_task: Box<GreenTask> = unsafe {
             cast::transmute(current_task_dupe)
         };
         current_task.sched.get_mut_ref().run_cleanup_job();
@@ -688,8 +691,10 @@ impl Scheduler {
 
     // * Context Swapping Helpers - Here be ugliness!
 
-    pub fn resume_task_immediately(~self, cur: ~GreenTask,
-                                   next: ~GreenTask) -> (~Scheduler, ~GreenTask) {
+    pub fn resume_task_immediately(~self,
+                                   cur: Box<GreenTask>,
+                                   next: Box<GreenTask>)
+                                   -> (Box<Scheduler>, Box<GreenTask>) {
         assert!(cur.is_sched());
         let mut cur = self.change_task_context(cur, next, |sched, stask| {
             assert!(sched.sched_task.is_none());
@@ -698,9 +703,10 @@ impl Scheduler {
         (cur.sched.take_unwrap(), cur)
     }
 
-    fn resume_task_immediately_cl(sched: ~Scheduler,
-                                  cur: ~GreenTask,
-                                  next: ~GreenTask) -> (~Scheduler, ~GreenTask) {
+    fn resume_task_immediately_cl(sched: Box<Scheduler>,
+                                  cur: Box<GreenTask>,
+                                  next: Box<GreenTask>)
+                                  -> (Box<Scheduler>, Box<GreenTask>) {
         sched.resume_task_immediately(cur, next)
     }
 
@@ -726,7 +732,7 @@ impl Scheduler {
     /// guaranteed that this function will not return before the given closure
     /// has returned.
     pub fn deschedule_running_task_and_then(mut ~self,
-                                            cur: ~GreenTask,
+                                            cur: Box<GreenTask>,
                                             f: |&mut Scheduler, BlockedTask|) {
         // Trickier - we need to get the scheduler task out of self
         // and use it as the destination.
@@ -736,8 +742,8 @@ impl Scheduler {
     }
 
     pub fn switch_running_tasks_and_then(~self,
-                                         cur: ~GreenTask,
-                                         next: ~GreenTask,
+                                         cur: Box<GreenTask>,
+                                         next: Box<GreenTask>,
                                          f: |&mut Scheduler, BlockedTask|) {
         // And here comes one of the sad moments in which a lock is used in a
         // core portion of the rust runtime. As always, this is highly
@@ -768,8 +774,10 @@ impl Scheduler {
         cur.put();
     }
 
-    fn switch_task(sched: ~Scheduler, cur: ~GreenTask,
-                   next: ~GreenTask) -> (~Scheduler, ~GreenTask) {
+    fn switch_task(sched: Box<Scheduler>,
+                   cur: Box<GreenTask>,
+                   next: Box<GreenTask>)
+                   -> (Box<Scheduler>, Box<GreenTask>) {
         let mut cur = sched.change_task_context(cur, next, |sched, last_task| {
             if last_task.is_sched() {
                 assert!(sched.sched_task.is_none());
@@ -785,7 +793,7 @@ impl Scheduler {
 
     /// Called by a running task to end execution, after which it will
     /// be recycled by the scheduler for reuse in a new task.
-    pub fn terminate_current_task(mut ~self, cur: ~GreenTask) -> ! {
+    pub fn terminate_current_task(mut ~self, cur: Box<GreenTask>) -> ! {
         // Similar to deschedule running task and then, but cannot go through
         // the task-blocking path. The task is already dying.
         let stask = self.sched_task.take_unwrap();
@@ -797,13 +805,13 @@ impl Scheduler {
         fail!("should never return!");
     }
 
-    pub fn run_task(~self, cur: ~GreenTask, next: ~GreenTask) {
+    pub fn run_task(~self, cur: Box<GreenTask>, next: Box<GreenTask>) {
         let (sched, task) =
             self.process_task(cur, next, Scheduler::switch_task);
         task.put_with_sched(sched);
     }
 
-    pub fn run_task_later(mut cur: ~GreenTask, next: ~GreenTask) {
+    pub fn run_task_later(mut cur: Box<GreenTask>, next: Box<GreenTask>) {
         let mut sched = cur.sched.take_unwrap();
         sched.enqueue_task(next);
         cur.put_with_sched(sched);
@@ -813,7 +821,7 @@ impl Scheduler {
     /// to introduce some amount of randomness to the scheduler. Currently the
     /// randomness is a result of performing a round of work stealing (which
     /// may end up stealing from the current scheduler).
-    pub fn yield_now(mut ~self, cur: ~GreenTask) {
+    pub fn yield_now(mut ~self, cur: Box<GreenTask>) {
         // Async handles trigger the scheduler by calling yield_now on the local
         // task, which eventually gets us to here. See comments in SchedRunner
         // for more info on this.
@@ -832,7 +840,7 @@ impl Scheduler {
         }
     }
 
-    pub fn maybe_yield(mut ~self, cur: ~GreenTask) {
+    pub fn maybe_yield(mut ~self, cur: Box<GreenTask>) {
         // It's possible for sched tasks to possibly call this function, and it
         // just means that they're likely sending on channels (which
         // occasionally call this function). Sched tasks follow different paths
@@ -881,20 +889,20 @@ impl Scheduler {
 
 // Supporting types
 
-type SchedulingFn = fn (~Scheduler, ~GreenTask, ~GreenTask)
-                            -> (~Scheduler, ~GreenTask);
+type SchedulingFn = fn(Box<Scheduler>, Box<GreenTask>, Box<GreenTask>)
+                       -> (Box<Scheduler>, Box<GreenTask>);
 
 pub enum SchedMessage {
     Wake,
     Shutdown,
-    NewNeighbor(deque::Stealer<~GreenTask>),
-    PinnedTask(~GreenTask),
-    TaskFromFriend(~GreenTask),
-    RunOnce(~GreenTask),
+    NewNeighbor(deque::Stealer<Box<GreenTask>>),
+    PinnedTask(Box<GreenTask>),
+    TaskFromFriend(Box<GreenTask>),
+    RunOnce(Box<GreenTask>),
 }
 
 pub struct SchedHandle {
-    remote: ~RemoteCallback:Send,
+    remote: Box<RemoteCallback:Send>,
     queue: msgq::Producer<SchedMessage>,
     pub sched_id: uint
 }
@@ -920,18 +928,18 @@ impl Callback for SchedRunner {
         // This function could be converted to `GreenTask::convert` if
         // absolutely necessary, but for cleanliness it is much better to not
         // use the conversion function.
-        let task: ~Task = Local::take();
+        let task: Box<Task> = Local::take();
         task.yield_now();
     }
 }
 
 struct CleanupJob {
-    task: ~GreenTask,
+    task: Box<GreenTask>,
     f: UnsafeTaskReceiver
 }
 
 impl CleanupJob {
-    pub fn new(task: ~GreenTask, f: UnsafeTaskReceiver) -> CleanupJob {
+    pub fn new(task: Box<GreenTask>, f: UnsafeTaskReceiver) -> CleanupJob {
         CleanupJob {
             task: task,
             f: f
@@ -948,14 +956,14 @@ impl CleanupJob {
 // complaining
 type UnsafeTaskReceiver = raw::Closure;
 trait ClosureConverter {
-    fn from_fn(|&mut Scheduler, ~GreenTask|) -> Self;
-    fn to_fn(self) -> |&mut Scheduler, ~GreenTask|;
+    fn from_fn(|&mut Scheduler, Box<GreenTask>|) -> Self;
+    fn to_fn(self) -> |&mut Scheduler, Box<GreenTask>|;
 }
 impl ClosureConverter for UnsafeTaskReceiver {
-    fn from_fn(f: |&mut Scheduler, ~GreenTask|) -> UnsafeTaskReceiver {
+    fn from_fn(f: |&mut Scheduler, Box<GreenTask>|) -> UnsafeTaskReceiver {
         unsafe { cast::transmute(f) }
     }
-    fn to_fn(self) -> |&mut Scheduler, ~GreenTask| {
+    fn to_fn(self) -> |&mut Scheduler, Box<GreenTask>| {
         unsafe { cast::transmute(self) }
     }
 }
@@ -1218,7 +1226,7 @@ mod test {
             // Signal from the special task that we are done.
             let (tx, rx) = channel::<()>();
 
-            fn run(next: ~GreenTask) {
+            fn run(next: Box<GreenTask>) {
                 let mut task = GreenTask::convert(Local::take());
                 let sched = task.sched.take_unwrap();
                 sched.run_task(task, next)
diff --git a/src/libgreen/simple.rs b/src/libgreen/simple.rs
index 37b0aa4f611..007084fa14d 100644
--- a/src/libgreen/simple.rs
+++ b/src/libgreen/simple.rs
@@ -28,7 +28,7 @@ struct SimpleTask {
 impl Runtime for SimpleTask {
     // Implement the simple tasks of descheduling and rescheduling, but only in
     // a simple number of cases.
-    fn deschedule(mut ~self, times: uint, mut cur_task: ~Task,
+    fn deschedule(mut ~self, times: uint, mut cur_task: Box<Task>,
                   f: |BlockedTask| -> Result<(), BlockedTask>) {
         assert!(times == 1);
 
@@ -55,7 +55,7 @@ impl Runtime for SimpleTask {
         }
         Local::put(cur_task);
     }
-    fn reawaken(mut ~self, mut to_wake: ~Task) {
+    fn reawaken(mut ~self, mut to_wake: Box<Task>) {
         let me = &mut *self as *mut SimpleTask;
         to_wake.put_runtime(self);
         unsafe {
@@ -70,18 +70,21 @@ impl Runtime for SimpleTask {
     // purpose. A "simple task" is just that, a very simple task that can't
     // really do a whole lot. The only purpose of the task is to get us off our
     // feet and running.
-    fn yield_now(~self, _cur_task: ~Task) { fail!() }
-    fn maybe_yield(~self, _cur_task: ~Task) { fail!() }
-    fn spawn_sibling(~self, _cur_task: ~Task, _opts: TaskOpts, _f: proc():Send) {
+    fn yield_now(~self, _cur_task: Box<Task>) { fail!() }
+    fn maybe_yield(~self, _cur_task: Box<Task>) { fail!() }
+    fn spawn_sibling(~self,
+                     _cur_task: Box<Task>,
+                     _opts: TaskOpts,
+                     _f: proc():Send) {
         fail!()
     }
     fn local_io<'a>(&'a mut self) -> Option<rtio::LocalIo<'a>> { None }
     fn stack_bounds(&self) -> (uint, uint) { fail!() }
     fn can_block(&self) -> bool { true }
-    fn wrap(~self) -> ~Any { fail!() }
+    fn wrap(~self) -> Box<Any> { fail!() }
 }
 
-pub fn task() -> ~Task {
+pub fn task() -> Box<Task> {
     let mut task = box Task::new();
     task.put_runtime(box SimpleTask {
         lock: unsafe {NativeMutex::new()},
diff --git a/src/libgreen/task.rs b/src/libgreen/task.rs
index 846fcdb1881..bc7752e98ea 100644
--- a/src/libgreen/task.rs
+++ b/src/libgreen/task.rs
@@ -50,12 +50,12 @@ pub struct GreenTask {
 
     /// Slot for maintaining ownership of a scheduler. If a task is running,
     /// this value will be Some(sched) where the task is running on "sched".
-    pub sched: Option<~Scheduler>,
+    pub sched: Option<Box<Scheduler>>,
 
     /// Temporary ownership slot of a std::rt::task::Task object. This is used
     /// to squirrel that libstd task away while we're performing green task
     /// operations.
-    pub task: Option<~Task>,
+    pub task: Option<Box<Task>>,
 
     /// Dictates whether this is a sched task or a normal green task
     pub task_type: TaskType,
@@ -85,8 +85,8 @@ pub enum Home {
 /// for all green tasks. This code is actually called after the initial context
 /// switch onto a green thread.
 ///
-/// The first argument to this function is the `~GreenTask` pointer, and the
-/// next two arguments are the user-provided procedure for running code.
+/// The first argument to this function is the `Box<GreenTask>` pointer, and
+/// the next two arguments are the user-provided procedure for running code.
 ///
 /// The goal for having this weird-looking function is to reduce the number of
 /// allocations done on a green-task startup as much as possible.
@@ -96,8 +96,8 @@ extern fn bootstrap_green_task(task: uint, code: *(), env: *()) -> ! {
         cast::transmute(raw::Procedure { code: code, env: env })
     };
 
-    // Acquire ownership of the `~GreenTask`
-    let mut task: ~GreenTask = unsafe { cast::transmute(task) };
+    // Acquire ownership of the `Box<GreenTask>`
+    let mut task: Box<GreenTask> = unsafe { cast::transmute(task) };
 
     // First code after swap to this new context. Run our cleanup job
     task.pool_id = {
@@ -129,7 +129,7 @@ impl GreenTask {
     /// and will not have any contained Task structure.
     pub fn new(stack_pool: &mut StackPool,
                stack_size: Option<uint>,
-               start: proc():Send) -> ~GreenTask {
+               start: proc():Send) -> Box<GreenTask> {
         GreenTask::new_homed(stack_pool, stack_size, AnySched, start)
     }
 
@@ -137,7 +137,7 @@ impl GreenTask {
     pub fn new_homed(stack_pool: &mut StackPool,
                      stack_size: Option<uint>,
                      home: Home,
-                     start: proc():Send) -> ~GreenTask {
+                     start: proc():Send) -> Box<GreenTask> {
         // Allocate ourselves a GreenTask structure
         let mut ops = GreenTask::new_typed(None, TypeGreen(Some(home)));
 
@@ -158,7 +158,7 @@ impl GreenTask {
     /// Creates a new green task with the specified coroutine and type, this is
     /// useful when creating scheduler tasks.
     pub fn new_typed(coroutine: Option<Coroutine>,
-                     task_type: TaskType) -> ~GreenTask {
+                     task_type: TaskType) -> Box<GreenTask> {
         box GreenTask {
             pool_id: 0,
             coroutine: coroutine,
@@ -175,7 +175,7 @@ impl GreenTask {
     /// new stack for this task.
     pub fn configure(pool: &mut StackPool,
                      opts: TaskOpts,
-                     f: proc():Send) -> ~GreenTask {
+                     f: proc():Send) -> Box<GreenTask> {
         let TaskOpts {
             notify_chan, name, stack_size,
             stderr, stdout,
@@ -204,7 +204,7 @@ impl GreenTask {
     ///
     /// This function will assert that the task is indeed a green task before
     /// returning (and will kill the entire process if this is wrong).
-    pub fn convert(mut task: ~Task) -> ~GreenTask {
+    pub fn convert(mut task: Box<Task>) -> Box<GreenTask> {
         match task.maybe_take_runtime::<GreenTask>() {
             Some(mut green) => {
                 green.put_task(task);
@@ -270,22 +270,24 @@ impl GreenTask {
         self as *GreenTask as uint
     }
 
-    pub unsafe fn from_uint(val: uint) -> ~GreenTask { cast::transmute(val) }
+    pub unsafe fn from_uint(val: uint) -> Box<GreenTask> {
+        cast::transmute(val)
+    }
 
     // Runtime glue functions and helpers
 
-    pub fn put_with_sched(mut ~self, sched: ~Scheduler) {
+    pub fn put_with_sched(mut ~self, sched: Box<Scheduler>) {
         assert!(self.sched.is_none());
         self.sched = Some(sched);
         self.put();
     }
 
-    pub fn put_task(&mut self, task: ~Task) {
+    pub fn put_task(&mut self, task: Box<Task>) {
         assert!(self.task.is_none());
         self.task = Some(task);
     }
 
-    pub fn swap(mut ~self) -> ~Task {
+    pub fn swap(mut ~self) -> Box<Task> {
         let mut task = self.task.take_unwrap();
         task.put_runtime(self);
         return task;
@@ -331,19 +333,19 @@ impl GreenTask {
 }
 
 impl Runtime for GreenTask {
-    fn yield_now(mut ~self, cur_task: ~Task) {
+    fn yield_now(mut ~self, cur_task: Box<Task>) {
         self.put_task(cur_task);
         let sched = self.sched.take_unwrap();
         sched.yield_now(self);
     }
 
-    fn maybe_yield(mut ~self, cur_task: ~Task) {
+    fn maybe_yield(mut ~self, cur_task: Box<Task>) {
         self.put_task(cur_task);
         let sched = self.sched.take_unwrap();
         sched.maybe_yield(self);
     }
 
-    fn deschedule(mut ~self, times: uint, cur_task: ~Task,
+    fn deschedule(mut ~self, times: uint, cur_task: Box<Task>,
                   f: |BlockedTask| -> Result<(), BlockedTask>) {
         self.put_task(cur_task);
         let mut sched = self.sched.take_unwrap();
@@ -392,14 +394,14 @@ impl Runtime for GreenTask {
         }
     }
 
-    fn reawaken(mut ~self, to_wake: ~Task) {
+    fn reawaken(mut ~self, to_wake: Box<Task>) {
         self.put_task(to_wake);
         assert!(self.sched.is_none());
 
         // Optimistically look for a local task, but if one's not available to
         // inspect (in order to see if it's in the same sched pool as we are),
         // then just use our remote wakeup routine and carry on!
-        let mut running_task: ~Task = match Local::try_take() {
+        let mut running_task: Box<Task> = match Local::try_take() {
             Some(task) => task,
             None => return self.reawaken_remotely()
         };
@@ -443,7 +445,10 @@ impl Runtime for GreenTask {
         }
     }
 
-    fn spawn_sibling(mut ~self, cur_task: ~Task, opts: TaskOpts, f: proc():Send) {
+    fn spawn_sibling(mut ~self,
+                     cur_task: Box<Task>,
+                     opts: TaskOpts,
+                     f: proc():Send) {
         self.put_task(cur_task);
 
         // Spawns a task into the current scheduler. We allocate the new task's
@@ -477,7 +482,7 @@ impl Runtime for GreenTask {
 
     fn can_block(&self) -> bool { false }
 
-    fn wrap(~self) -> ~Any { self as ~Any }
+    fn wrap(~self) -> Box<Any> { self as Box<Any> }
 }
 
 #[cfg(test)]
@@ -572,7 +577,7 @@ mod tests {
         let (tx, rx) = channel();
         spawn_opts(TaskOpts::new(), proc() {
             spawn(proc() {
-                let mut task: ~Task = Local::take();
+                let mut task: Box<Task> = Local::take();
                 match task.maybe_take_runtime::<GreenTask>() {
                     Some(ops) => {
                         task.put_runtime(ops);
diff --git a/src/libhexfloat/lib.rs b/src/libhexfloat/lib.rs
index 100bec23775..fac4eaf9fe5 100644
--- a/src/libhexfloat/lib.rs
+++ b/src/libhexfloat/lib.rs
@@ -61,7 +61,7 @@ use syntax::parse::token;
 #[macro_registrar]
 pub fn macro_registrar(register: |Name, SyntaxExtension|) {
     register(token::intern("hexfloat"),
-        NormalTT(~BasicMacroExpander {
+        NormalTT(box BasicMacroExpander {
             expander: expand_syntax_ext,
             span: None,
         },
@@ -97,7 +97,8 @@ fn hex_float_lit_err(s: &str) -> Option<(uint, ~str)> {
     }
 }
 
-pub fn expand_syntax_ext(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) -> ~base::MacResult {
+pub fn expand_syntax_ext(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
+                         -> Box<base::MacResult> {
     let (expr, ty_lit) = parse_tts(cx, tts);
 
     let ty = match ty_lit {
diff --git a/src/liblog/lib.rs b/src/liblog/lib.rs
index a32a42636b6..035a81f4143 100644
--- a/src/liblog/lib.rs
+++ b/src/liblog/lib.rs
@@ -158,7 +158,7 @@ pub static WARN: u32 = 2;
 /// Error log level
 pub static ERROR: u32 = 1;
 
-local_data_key!(local_logger: ~Logger:Send)
+local_data_key!(local_logger: Box<Logger:Send>)
 
 /// A trait used to represent an interface to a task-local logger. Each task
 /// can have its own custom logger which can respond to logging messages
@@ -229,7 +229,7 @@ pub fn log(level: u32, loc: &'static LogLocation, args: &fmt::Arguments) {
     // frob the slot while we're doing the logging. This will destroy any logger
     // set during logging.
     let mut logger = local_data::pop(local_logger).unwrap_or_else(|| {
-        box DefaultLogger { handle: io::stderr() } as ~Logger:Send
+        box DefaultLogger { handle: io::stderr() } as Box<Logger:Send>
     });
     logger.log(&LogRecord {
         level: LogLevel(level),
@@ -249,7 +249,7 @@ pub fn log_level() -> u32 { unsafe { LOG_LEVEL } }
 
 /// Replaces the task-local logger with the specified logger, returning the old
 /// logger.
-pub fn set_logger(logger: ~Logger:Send) -> Option<~Logger:Send> {
+pub fn set_logger(logger: Box<Logger:Send>) -> Option<Box<Logger:Send>> {
     let prev = local_data::pop(local_logger);
     local_data::set(local_logger, logger);
     return prev;
@@ -351,7 +351,7 @@ fn init() {
         // Schedule the cleanup for this global for when the runtime exits.
         rt::at_exit(proc() {
             assert!(!DIRECTIVES.is_null());
-            let _directives: ~Vec<directive::LogDirective> =
+            let _directives: Box<Vec<directive::LogDirective>> =
                 cast::transmute(DIRECTIVES);
             DIRECTIVES = 0 as *Vec<directive::LogDirective>;
         });
diff --git a/src/libnative/io/file_unix.rs b/src/libnative/io/file_unix.rs
index 94ca6027841..2727f9a0b09 100644
--- a/src/libnative/io/file_unix.rs
+++ b/src/libnative/io/file_unix.rs
@@ -10,12 +10,12 @@
 
 //! Blocking posix-based file I/O
 
+use libc::{c_int, c_void};
+use libc;
 use std::sync::arc::UnsafeArc;
 use std::c_str::CString;
 use std::io::IoError;
 use std::io;
-use libc::{c_int, c_void};
-use libc;
 use std::mem;
 use std::rt::rtio;
 
@@ -175,8 +175,8 @@ impl rtio::RtioPipe for FileDesc {
     fn write(&mut self, buf: &[u8]) -> Result<(), IoError> {
         self.inner_write(buf)
     }
-    fn clone(&self) -> ~rtio::RtioPipe:Send {
-        box FileDesc { inner: self.inner.clone() } as ~rtio::RtioPipe:Send
+    fn clone(&self) -> Box<rtio::RtioPipe:Send> {
+        box FileDesc { inner: self.inner.clone() } as Box<rtio::RtioPipe:Send>
     }
 }
 
diff --git a/src/libnative/io/file_win32.rs b/src/libnative/io/file_win32.rs
index 54bb2201314..018907303b8 100644
--- a/src/libnative/io/file_win32.rs
+++ b/src/libnative/io/file_win32.rs
@@ -207,8 +207,8 @@ impl rtio::RtioPipe for FileDesc {
     fn write(&mut self, buf: &[u8]) -> Result<(), IoError> {
         self.inner_write(buf)
     }
-    fn clone(&self) -> ~rtio::RtioPipe:Send {
-        box FileDesc { inner: self.inner.clone() } as ~rtio::RtioPipe:Send
+    fn clone(&self) -> Box<rtio::RtioPipe:Send> {
+        box FileDesc { inner: self.inner.clone() } as Box<rtio::RtioPipe:Send>
     }
 }
 
diff --git a/src/libnative/io/mod.rs b/src/libnative/io/mod.rs
index fb92d0d55cf..58fcd60f138 100644
--- a/src/libnative/io/mod.rs
+++ b/src/libnative/io/mod.rs
@@ -21,19 +21,19 @@
 //! play. The only dependencies of these modules are the normal system libraries
 //! that you would find on the respective platform.
 
+use libc::c_int;
+use libc;
 use std::c_str::CString;
 use std::io;
 use std::io::IoError;
 use std::io::net::ip::SocketAddr;
 use std::io::process::ProcessConfig;
 use std::io::signal::Signum;
-use libc::c_int;
-use libc;
 use std::os;
 use std::rt::rtio;
-use std::rt::rtio::{RtioTcpStream, RtioTcpListener, RtioUdpSocket,
-                    RtioUnixListener, RtioPipe, RtioFileStream, RtioProcess,
-                    RtioSignal, RtioTTY, CloseBehavior, RtioTimer};
+use std::rt::rtio::{RtioTcpStream, RtioTcpListener, RtioUdpSocket};
+use std::rt::rtio::{RtioUnixListener, RtioPipe, RtioFileStream, RtioProcess};
+use std::rt::rtio::{RtioSignal, RtioTTY, CloseBehavior, RtioTimer};
 use ai = std::io::net::addrinfo;
 
 // Local re-exports
@@ -166,21 +166,32 @@ impl IoFactory {
 impl rtio::IoFactory for IoFactory {
     // networking
     fn tcp_connect(&mut self, addr: SocketAddr,
-                   timeout: Option<u64>) -> IoResult<~RtioTcpStream:Send> {
-        net::TcpStream::connect(addr, timeout).map(|s| box s as ~RtioTcpStream:Send)
+                   timeout: Option<u64>) -> IoResult<Box<RtioTcpStream:Send>> {
+        net::TcpStream::connect(addr, timeout).map(|s| {
+            box s as Box<RtioTcpStream:Send>
+        })
     }
-    fn tcp_bind(&mut self, addr: SocketAddr) -> IoResult<~RtioTcpListener:Send> {
-        net::TcpListener::bind(addr).map(|s| box s as ~RtioTcpListener:Send)
+    fn tcp_bind(&mut self, addr: SocketAddr)
+                -> IoResult<Box<RtioTcpListener:Send>> {
+        net::TcpListener::bind(addr).map(|s| {
+            box s as Box<RtioTcpListener:Send>
+        })
     }
-    fn udp_bind(&mut self, addr: SocketAddr) -> IoResult<~RtioUdpSocket:Send> {
-        net::UdpSocket::bind(addr).map(|u| box u as ~RtioUdpSocket:Send)
+    fn udp_bind(&mut self, addr: SocketAddr)
+                -> IoResult<Box<RtioUdpSocket:Send>> {
+        net::UdpSocket::bind(addr).map(|u| box u as Box<RtioUdpSocket:Send>)
     }
-    fn unix_bind(&mut self, path: &CString) -> IoResult<~RtioUnixListener:Send> {
-        pipe::UnixListener::bind(path).map(|s| box s as ~RtioUnixListener:Send)
+    fn unix_bind(&mut self, path: &CString)
+                 -> IoResult<Box<RtioUnixListener:Send>> {
+        pipe::UnixListener::bind(path).map(|s| {
+            box s as Box<RtioUnixListener:Send>
+        })
     }
     fn unix_connect(&mut self, path: &CString,
-                    timeout: Option<u64>) -> IoResult<~RtioPipe:Send> {
-        pipe::UnixStream::connect(path, timeout).map(|s| box s as ~RtioPipe:Send)
+                    timeout: Option<u64>) -> IoResult<Box<RtioPipe:Send>> {
+        pipe::UnixStream::connect(path, timeout).map(|s| {
+            box s as Box<RtioPipe:Send>
+        })
     }
     fn get_host_addresses(&mut self, host: Option<&str>, servname: Option<&str>,
                           hint: Option<ai::Hint>) -> IoResult<~[ai::Info]> {
@@ -188,17 +199,17 @@ impl rtio::IoFactory for IoFactory {
     }
 
     // filesystem operations
-    fn fs_from_raw_fd(&mut self, fd: c_int,
-                      close: CloseBehavior) -> ~RtioFileStream:Send {
+    fn fs_from_raw_fd(&mut self, fd: c_int, close: CloseBehavior)
+                      -> Box<RtioFileStream:Send> {
         let close = match close {
             rtio::CloseSynchronously | rtio::CloseAsynchronously => true,
             rtio::DontClose => false
         };
-        box file::FileDesc::new(fd, close) as ~RtioFileStream:Send
+        box file::FileDesc::new(fd, close) as Box<RtioFileStream:Send>
     }
     fn fs_open(&mut self, path: &CString, fm: io::FileMode, fa: io::FileAccess)
-        -> IoResult<~RtioFileStream:Send> {
-        file::open(path, fm, fa).map(|fd| box fd as ~RtioFileStream:Send)
+        -> IoResult<Box<RtioFileStream:Send>> {
+        file::open(path, fm, fa).map(|fd| box fd as Box<RtioFileStream:Send>)
     }
     fn fs_unlink(&mut self, path: &CString) -> IoResult<()> {
         file::unlink(path)
@@ -244,27 +255,29 @@ impl rtio::IoFactory for IoFactory {
     }
 
     // misc
-    fn timer_init(&mut self) -> IoResult<~RtioTimer:Send> {
-        timer::Timer::new().map(|t| box t as ~RtioTimer:Send)
+    fn timer_init(&mut self) -> IoResult<Box<RtioTimer:Send>> {
+        timer::Timer::new().map(|t| box t as Box<RtioTimer:Send>)
     }
     fn spawn(&mut self, config: ProcessConfig)
-            -> IoResult<(~RtioProcess:Send, ~[Option<~RtioPipe:Send>])> {
+            -> IoResult<(Box<RtioProcess:Send>,
+                         ~[Option<Box<RtioPipe:Send>>])> {
         process::Process::spawn(config).map(|(p, io)| {
-            (box p as ~RtioProcess:Send,
-             io.move_iter().map(|p| p.map(|p| box p as ~RtioPipe:Send)).collect())
+            (box p as Box<RtioProcess:Send>,
+             io.move_iter().map(|p| p.map(|p| {
+                 box p as Box<RtioPipe:Send>
+             })).collect())
         })
     }
     fn kill(&mut self, pid: libc::pid_t, signum: int) -> IoResult<()> {
         process::Process::kill(pid, signum)
     }
-    fn pipe_open(&mut self, fd: c_int) -> IoResult<~RtioPipe:Send> {
-        Ok(box file::FileDesc::new(fd, true) as ~RtioPipe:Send)
+    fn pipe_open(&mut self, fd: c_int) -> IoResult<Box<RtioPipe:Send>> {
+        Ok(box file::FileDesc::new(fd, true) as Box<RtioPipe:Send>)
     }
     fn tty_open(&mut self, fd: c_int, _readable: bool)
-        -> IoResult<~RtioTTY:Send>
-    {
+                -> IoResult<Box<RtioTTY:Send>> {
         if unsafe { libc::isatty(fd) } != 0 {
-            Ok(box file::FileDesc::new(fd, true) as ~RtioTTY:Send)
+            Ok(box file::FileDesc::new(fd, true) as Box<RtioTTY:Send>)
         } else {
             Err(IoError {
                 kind: io::MismatchedFileTypeForOperation,
@@ -274,7 +287,7 @@ impl rtio::IoFactory for IoFactory {
         }
     }
     fn signal(&mut self, _signal: Signum, _channel: Sender<Signum>)
-        -> IoResult<~RtioSignal:Send> {
+              -> IoResult<Box<RtioSignal:Send>> {
         Err(unimpl())
     }
 }
diff --git a/src/libnative/io/net.rs b/src/libnative/io/net.rs
index c47e549b20a..880cbaabaf8 100644
--- a/src/libnative/io/net.rs
+++ b/src/libnative/io/net.rs
@@ -351,8 +351,10 @@ impl rtio::RtioTcpStream for TcpStream {
         self.set_keepalive(None)
     }
 
-    fn clone(&self) -> ~rtio::RtioTcpStream:Send {
-        box TcpStream { inner: self.inner.clone() } as ~rtio::RtioTcpStream:Send
+    fn clone(&self) -> Box<rtio::RtioTcpStream:Send> {
+        box TcpStream {
+            inner: self.inner.clone(),
+        } as Box<rtio::RtioTcpStream:Send>
     }
     fn close_write(&mut self) -> IoResult<()> {
         super::mkerr_libc(unsafe {
@@ -418,8 +420,10 @@ impl TcpListener {
 }
 
 impl rtio::RtioTcpListener for TcpListener {
-    fn listen(~self) -> IoResult<~rtio::RtioTcpAcceptor:Send> {
-        self.native_listen(128).map(|a| box a as ~rtio::RtioTcpAcceptor:Send)
+    fn listen(~self) -> IoResult<Box<rtio::RtioTcpAcceptor:Send>> {
+        self.native_listen(128).map(|a| {
+            box a as Box<rtio::RtioTcpAcceptor:Send>
+        })
     }
 }
 
@@ -465,8 +469,8 @@ impl rtio::RtioSocket for TcpAcceptor {
 }
 
 impl rtio::RtioTcpAcceptor for TcpAcceptor {
-    fn accept(&mut self) -> IoResult<~rtio::RtioTcpStream:Send> {
-        self.native_accept().map(|s| box s as ~rtio::RtioTcpStream:Send)
+    fn accept(&mut self) -> IoResult<Box<rtio::RtioTcpStream:Send>> {
+        self.native_accept().map(|s| box s as Box<rtio::RtioTcpStream:Send>)
     }
 
     fn accept_simultaneously(&mut self) -> IoResult<()> { Ok(()) }
@@ -637,7 +641,9 @@ impl rtio::RtioUdpSocket for UdpSocket {
         self.set_broadcast(false)
     }
 
-    fn clone(&self) -> ~rtio::RtioUdpSocket:Send {
-        box UdpSocket { inner: self.inner.clone() } as ~rtio::RtioUdpSocket:Send
+    fn clone(&self) -> Box<rtio::RtioUdpSocket:Send> {
+        box UdpSocket {
+            inner: self.inner.clone(),
+        } as Box<rtio::RtioUdpSocket:Send>
     }
 }
diff --git a/src/libnative/io/pipe_unix.rs b/src/libnative/io/pipe_unix.rs
index 178247f3190..65e9c7448c2 100644
--- a/src/libnative/io/pipe_unix.rs
+++ b/src/libnative/io/pipe_unix.rs
@@ -144,8 +144,10 @@ impl rtio::RtioPipe for UnixStream {
         }
     }
 
-    fn clone(&self) -> ~rtio::RtioPipe:Send {
-        box UnixStream { inner: self.inner.clone() } as ~rtio::RtioPipe:Send
+    fn clone(&self) -> Box<rtio::RtioPipe:Send> {
+        box UnixStream {
+            inner: self.inner.clone(),
+        } as Box<rtio::RtioPipe:Send>
     }
 }
 
@@ -176,8 +178,10 @@ impl UnixListener {
 }
 
 impl rtio::RtioUnixListener for UnixListener {
-    fn listen(~self) -> IoResult<~rtio::RtioUnixAcceptor:Send> {
-        self.native_listen(128).map(|a| box a as ~rtio::RtioUnixAcceptor:Send)
+    fn listen(~self) -> IoResult<Box<rtio::RtioUnixAcceptor:Send>> {
+        self.native_listen(128).map(|a| {
+            box a as Box<rtio::RtioUnixAcceptor:Send>
+        })
     }
 }
 
@@ -209,8 +213,8 @@ impl UnixAcceptor {
 }
 
 impl rtio::RtioUnixAcceptor for UnixAcceptor {
-    fn accept(&mut self) -> IoResult<~rtio::RtioPipe:Send> {
-        self.native_accept().map(|s| box s as ~rtio::RtioPipe:Send)
+    fn accept(&mut self) -> IoResult<Box<rtio::RtioPipe:Send>> {
+        self.native_accept().map(|s| box s as Box<rtio::RtioPipe:Send>)
     }
     fn set_timeout(&mut self, timeout: Option<u64>) {
         self.deadline = timeout.map(|a| ::io::timer::now() + a).unwrap_or(0);
diff --git a/src/libnative/io/pipe_win32.rs b/src/libnative/io/pipe_win32.rs
index bf7f82ef662..f1239285434 100644
--- a/src/libnative/io/pipe_win32.rs
+++ b/src/libnative/io/pipe_win32.rs
@@ -353,12 +353,12 @@ impl rtio::RtioPipe for UnixStream {
         Ok(())
     }
 
-    fn clone(&self) -> ~rtio::RtioPipe:Send {
+    fn clone(&self) -> Box<rtio::RtioPipe:Send> {
         box UnixStream {
             inner: self.inner.clone(),
             read: None,
             write: None,
-        } as ~rtio::RtioPipe:Send
+        } as Box<rtio::RtioPipe:Send>
     }
 }
 
@@ -402,8 +402,10 @@ impl Drop for UnixListener {
 }
 
 impl rtio::RtioUnixListener for UnixListener {
-    fn listen(~self) -> IoResult<~rtio::RtioUnixAcceptor:Send> {
-        self.native_listen().map(|a| box a as ~rtio::RtioUnixAcceptor:Send)
+    fn listen(~self) -> IoResult<Box<rtio::RtioUnixAcceptor:Send>> {
+        self.native_listen().map(|a| {
+            box a as Box<rtio::RtioUnixAcceptor:Send>
+        })
     }
 }
 
@@ -526,8 +528,8 @@ impl UnixAcceptor {
 }
 
 impl rtio::RtioUnixAcceptor for UnixAcceptor {
-    fn accept(&mut self) -> IoResult<~rtio::RtioPipe:Send> {
-        self.native_accept().map(|s| box s as ~rtio::RtioPipe:Send)
+    fn accept(&mut self) -> IoResult<Box<rtio::RtioPipe:Send>> {
+        self.native_accept().map(|s| box s as Box<rtio::RtioPipe:Send>)
     }
     fn set_timeout(&mut self, timeout: Option<u64>) {
         self.deadline = timeout.map(|i| i + ::io::timer::now()).unwrap_or(0);
diff --git a/src/libnative/io/timer_helper.rs b/src/libnative/io/timer_helper.rs
index 298dd2f368d..3bf967cb426 100644
--- a/src/libnative/io/timer_helper.rs
+++ b/src/libnative/io/timer_helper.rs
@@ -86,7 +86,7 @@ fn shutdown() {
     // Clean up after ther helper thread
     unsafe {
         imp::close(HELPER_SIGNAL);
-        let _chan: ~Sender<Req> = cast::transmute(HELPER_CHAN);
+        let _chan: Box<Sender<Req>> = cast::transmute(HELPER_CHAN);
         HELPER_CHAN = 0 as *mut Sender<Req>;
         HELPER_SIGNAL = 0 as imp::signal;
     }
diff --git a/src/libnative/io/timer_unix.rs b/src/libnative/io/timer_unix.rs
index 8435c05c771..e008e6fb9e9 100644
--- a/src/libnative/io/timer_unix.rs
+++ b/src/libnative/io/timer_unix.rs
@@ -60,7 +60,7 @@ use io::timer_helper;
 
 pub struct Timer {
     id: uint,
-    inner: Option<~Inner>,
+    inner: Option<Box<Inner>>,
 }
 
 struct Inner {
@@ -74,11 +74,11 @@ struct Inner {
 #[allow(visible_private_types)]
 pub enum Req {
     // Add a new timer to the helper thread.
-    NewTimer(~Inner),
+    NewTimer(Box<Inner>),
 
     // Remove a timer based on its id and then send it back on the channel
     // provided
-    RemoveTimer(uint, Sender<~Inner>),
+    RemoveTimer(uint, Sender<Box<Inner>>),
 
     // Shut down the loop and then ACK this channel once it's shut down
     Shutdown,
@@ -102,11 +102,11 @@ fn helper(input: libc::c_int, messages: Receiver<Req>) {
     // active timers are those which are able to be selected upon (and it's a
     // sorted list, and dead timers are those which have expired, but ownership
     // hasn't yet been transferred back to the timer itself.
-    let mut active: Vec<~Inner> = vec![];
+    let mut active: Vec<Box<Inner>> = vec![];
     let mut dead = vec![];
 
     // inserts a timer into an array of timers (sorted by firing time)
-    fn insert(t: ~Inner, active: &mut Vec<~Inner>) {
+    fn insert(t: Box<Inner>, active: &mut Vec<Box<Inner>>) {
         match active.iter().position(|tm| tm.target > t.target) {
             Some(pos) => { active.insert(pos, t); }
             None => { active.push(t); }
@@ -114,7 +114,8 @@ fn helper(input: libc::c_int, messages: Receiver<Req>) {
     }
 
     // signals the first requests in the queue, possible re-enqueueing it.
-    fn signal(active: &mut Vec<~Inner>, dead: &mut Vec<(uint, ~Inner)>) {
+    fn signal(active: &mut Vec<Box<Inner>>,
+              dead: &mut Vec<(uint, Box<Inner>)>) {
         let mut timer = match active.shift() {
             Some(timer) => timer, None => return
         };
@@ -229,7 +230,7 @@ impl Timer {
         }
     }
 
-    fn inner(&mut self) -> ~Inner {
+    fn inner(&mut self) -> Box<Inner> {
         match self.inner.take() {
             Some(i) => i,
             None => {
diff --git a/src/libnative/task.rs b/src/libnative/task.rs
index 512080e4204..d5b02dc007b 100644
--- a/src/libnative/task.rs
+++ b/src/libnative/task.rs
@@ -31,7 +31,7 @@ use io;
 use task;
 
 /// Creates a new Task which is ready to execute as a 1:1 task.
-pub fn new(stack_bounds: (uint, uint)) -> ~Task {
+pub fn new(stack_bounds: (uint, uint)) -> Box<Task> {
     let mut task = box Task::new();
     let mut ops = ops();
     ops.stack_bounds = stack_bounds;
@@ -39,7 +39,7 @@ pub fn new(stack_bounds: (uint, uint)) -> ~Task {
     return task;
 }
 
-fn ops() -> ~Ops {
+fn ops() -> Box<Ops> {
     box Ops {
         lock: unsafe { NativeMutex::new() },
         awoken: false,
@@ -119,22 +119,22 @@ struct Ops {
 }
 
 impl rt::Runtime for Ops {
-    fn yield_now(~self, mut cur_task: ~Task) {
+    fn yield_now(~self, mut cur_task: Box<Task>) {
         // put the task back in TLS and then invoke the OS thread yield
         cur_task.put_runtime(self);
         Local::put(cur_task);
         Thread::yield_now();
     }
 
-    fn maybe_yield(~self, mut cur_task: ~Task) {
+    fn maybe_yield(~self, mut cur_task: Box<Task>) {
         // just put the task back in TLS, on OS threads we never need to
         // opportunistically yield b/c the OS will do that for us (preemption)
         cur_task.put_runtime(self);
         Local::put(cur_task);
     }
 
-    fn wrap(~self) -> ~Any {
-        self as ~Any
+    fn wrap(~self) -> Box<Any> {
+        self as Box<Any>
     }
 
     fn stack_bounds(&self) -> (uint, uint) { self.stack_bounds }
@@ -159,8 +159,8 @@ impl rt::Runtime for Ops {
     // from the wakeup thread back to this thread about the task pointer, and
     // there's really no need to. In order to get around this, we cast the task
     // to a `uint` which is then used at the end of this function to cast back
-    // to a `~Task` object. Naturally, this looks like it violates ownership
-    // semantics in that there may be two `~Task` objects.
+    // to a `Box<Task>` object. Naturally, this looks like it violates
+    // ownership semantics in that there may be two `Box<Task>` objects.
     //
     // The fun part is that the wakeup half of this implementation knows to
     // "forget" the task on the other end. This means that the awakening half of
@@ -180,7 +180,7 @@ impl rt::Runtime for Ops {
     // `awoken` field which indicates whether we were actually woken up via some
     // invocation of `reawaken`. This flag is only ever accessed inside the
     // lock, so there's no need to make it atomic.
-    fn deschedule(mut ~self, times: uint, mut cur_task: ~Task,
+    fn deschedule(mut ~self, times: uint, mut cur_task: Box<Task>,
                   f: |BlockedTask| -> Result<(), BlockedTask>) {
         let me = &mut *self as *mut Ops;
         cur_task.put_runtime(self);
@@ -238,7 +238,7 @@ impl rt::Runtime for Ops {
 
     // See the comments on `deschedule` for why the task is forgotten here, and
     // why it's valid to do so.
-    fn reawaken(mut ~self, mut to_wake: ~Task) {
+    fn reawaken(mut ~self, mut to_wake: Box<Task>) {
         unsafe {
             let me = &mut *self as *mut Ops;
             to_wake.put_runtime(self);
@@ -249,7 +249,10 @@ impl rt::Runtime for Ops {
         }
     }
 
-    fn spawn_sibling(~self, mut cur_task: ~Task, opts: TaskOpts, f: proc():Send) {
+    fn spawn_sibling(~self,
+                     mut cur_task: Box<Task>,
+                     opts: TaskOpts,
+                     f: proc():Send) {
         cur_task.put_runtime(self);
         Local::put(cur_task);
 
@@ -342,7 +345,7 @@ mod tests {
         let (tx, rx) = channel();
         spawn(proc() {
             spawn(proc() {
-                let mut task: ~Task = Local::take();
+                let mut task: Box<Task> = Local::take();
                 match task.maybe_take_runtime::<Ops>() {
                     Some(ops) => {
                         task.put_runtime(ops);
diff --git a/src/librand/lib.rs b/src/librand/lib.rs
index 3393abc8b26..d5a2c163a90 100644
--- a/src/librand/lib.rs
+++ b/src/librand/lib.rs
@@ -57,7 +57,7 @@ if rng.gen() { // bool
 ```
 
 ```rust
-let tuple_ptr = rand::random::<~(f64, char)>();
+let tuple_ptr = rand::random::<Box<(f64, char)>>();
 println!("{:?}", tuple_ptr)
 ```
 */
@@ -569,7 +569,7 @@ type TaskRngInner = reseeding::ReseedingRng<StdRng, TaskRngReseeder>;
 /// The task-local RNG.
 pub struct TaskRng {
     // This points into TLS (specifically, it points to the endpoint
-    // of a ~ stored in TLS, to make it robust against TLS moving
+    // of a Box stored in TLS, to make it robust against TLS moving
     // things internally) and so this struct cannot be legally
     // transferred between tasks *and* it's unsafe to deallocate the
     // RNG other than when a task is finished.
@@ -582,7 +582,7 @@ pub struct TaskRng {
 }
 
 // used to make space in TLS for a random number generator
-local_data_key!(TASK_RNG_KEY: ~TaskRngInner)
+local_data_key!(TASK_RNG_KEY: Box<TaskRngInner>)
 
 /// Retrieve the lazily-initialized task-local random number
 /// generator, seeded by the system. Intended to be used in method
@@ -833,7 +833,9 @@ mod test {
         let _f : f32 = random();
         let _o : Option<Option<i8>> = random();
         let _many : ((),
-                     (~uint, @int, ~Option<~(@u32, ~(@bool,))>),
+                     (Box<uint>,
+                      @int,
+                      Box<Option<Box<(@u32, Box<(@bool,)>)>>>),
                      (u8, i8, u16, i16, u32, i32, u64, i64),
                      (f32, (f64, (f64,)))) = random();
     }
diff --git a/src/librand/rand_impls.rs b/src/librand/rand_impls.rs
index b4551fcc312..5846cb5f312 100644
--- a/src/librand/rand_impls.rs
+++ b/src/librand/rand_impls.rs
@@ -214,9 +214,9 @@ impl<T:Rand> Rand for Option<T> {
     }
 }
 
-impl<T: Rand> Rand for ~T {
+impl<T: Rand> Rand for Box<T> {
     #[inline]
-    fn rand<R: Rng>(rng: &mut R) -> ~T { box rng.gen() }
+    fn rand<R: Rng>(rng: &mut R) -> Box<T> { box rng.gen() }
 }
 
 impl<T: Rand + 'static> Rand for @T {
diff --git a/src/libregex/parse.rs b/src/libregex/parse.rs
index 9feceff5375..3a28f0d1ed5 100644
--- a/src/libregex/parse.rs
+++ b/src/libregex/parse.rs
@@ -59,12 +59,12 @@ pub enum Ast {
     Begin(Flags),
     End(Flags),
     WordBoundary(Flags),
-    Capture(uint, Option<~str>, ~Ast),
+    Capture(uint, Option<~str>, Box<Ast>),
     // Represent concatenation as a flat vector to avoid blowing the
     // stack in the compiler.
     Cat(Vec<Ast>),
-    Alt(~Ast, ~Ast),
-    Rep(~Ast, Repeater, Greed),
+    Alt(Box<Ast>, Box<Ast>),
+    Rep(Box<Ast>, Repeater, Greed),
 }
 
 #[deriving(Show, Eq, Clone)]
@@ -245,7 +245,7 @@ impl<'a> Parser<'a> {
                     // alternate and make it a capture.
                     if cap.is_some() {
                         let ast = try!(self.pop_ast());
-                        self.push(Capture(cap.unwrap(), cap_name, ~ast));
+                        self.push(Capture(cap.unwrap(), cap_name, box ast));
                     }
                 }
                 '|' => {
@@ -331,7 +331,7 @@ impl<'a> Parser<'a> {
             _ => {}
         }
         let greed = try!(self.get_next_greedy());
-        self.push(Rep(~ast, rep, greed));
+        self.push(Rep(box ast, rep, greed));
         Ok(())
     }
 
@@ -411,13 +411,13 @@ impl<'a> Parser<'a> {
                         let flags = negated | (self.flags & FLAG_NOCASE);
                         let mut ast = Class(combine_ranges(ranges), flags);
                         for alt in alts.move_iter() {
-                            ast = Alt(~alt, ~ast)
+                            ast = Alt(box alt, box ast)
                         }
                         self.push(ast);
                     } else if alts.len() > 0 {
                         let mut ast = alts.pop().unwrap();
                         for alt in alts.move_iter() {
-                            ast = Alt(~alt, ~ast)
+                            ast = Alt(box alt, box ast)
                         }
                         self.push(ast);
                     }
@@ -548,7 +548,7 @@ impl<'a> Parser<'a> {
             for _ in iter::range(0, min) {
                 self.push(ast.clone())
             }
-            self.push(Rep(~ast, ZeroMore, greed));
+            self.push(Rep(box ast, ZeroMore, greed));
         } else {
             // Require N copies of what's on the stack and then repeat it
             // up to M times optionally.
@@ -558,7 +558,7 @@ impl<'a> Parser<'a> {
             }
             if max.is_some() {
                 for _ in iter::range(min, max.unwrap()) {
-                    self.push(Rep(~ast.clone(), ZeroOne, greed))
+                    self.push(Rep(box ast.clone(), ZeroOne, greed))
                 }
             }
             // It's possible that we popped something off the stack but
@@ -842,7 +842,7 @@ impl<'a> Parser<'a> {
         // thrown away). But be careful with overflow---we can't count on the
         // open paren to be there.
         if from > 0 { from = from - 1}
-        let ast = try!(self.build_from(from, |l,r| Alt(~l, ~r)));
+        let ast = try!(self.build_from(from, |l,r| Alt(box l, box r)));
         self.push(ast);
         Ok(())
     }
diff --git a/src/libregex_macros/lib.rs b/src/libregex_macros/lib.rs
index 6706fb16136..c2d3872950f 100644
--- a/src/libregex_macros/lib.rs
+++ b/src/libregex_macros/lib.rs
@@ -49,7 +49,7 @@ use regex::native::{
 #[macro_registrar]
 #[doc(hidden)]
 pub fn macro_registrar(register: |ast::Name, SyntaxExtension|) {
-    let expander = ~BasicMacroExpander { expander: native, span: None };
+    let expander = box BasicMacroExpander { expander: native, span: None };
     register(token::intern("regex"), NormalTT(expander, None))
 }
 
@@ -76,7 +76,7 @@ pub fn macro_registrar(register: |ast::Name, SyntaxExtension|) {
 /// first before trying to understand the code generator. The implementation
 /// strategy is identical and vm.rs has comments and will be easier to follow.
 fn native(cx: &mut ExtCtxt, sp: codemap::Span, tts: &[ast::TokenTree])
-         -> ~MacResult {
+          -> Box<MacResult> {
     let regex = match parse(cx, tts) {
         Some(r) => r,
         // error is logged in 'parse' with cx.span_err
diff --git a/src/librustc/driver/driver.rs b/src/librustc/driver/driver.rs
index 247c41a6069..fc903db6d04 100644
--- a/src/librustc/driver/driver.rs
+++ b/src/librustc/driver/driver.rs
@@ -677,11 +677,11 @@ pub fn pretty_print_input(sess: Session,
     let mut rdr = MemReader::new(src);
 
     let out = match ofile {
-        None => box io::stdout() as ~Writer,
+        None => box io::stdout() as Box<Writer>,
         Some(p) => {
             let r = io::File::create(&p);
             match r {
-                Ok(w) => box w as ~Writer,
+                Ok(w) => box w as Box<Writer>,
                 Err(e) => fail!("print-print failed to open {} due to {}",
                                 p.display(), e),
             }
diff --git a/src/librustc/metadata/tyencode.rs b/src/librustc/metadata/tyencode.rs
index 3a196c5ffab..900fba831d9 100644
--- a/src/librustc/metadata/tyencode.rs
+++ b/src/librustc/metadata/tyencode.rs
@@ -229,7 +229,12 @@ fn enc_sty(w: &mut MemWriter, cx: &ctxt, st: &ty::sty) {
             enc_substs(w, cx, substs);
             mywrite!(w, "]");
         }
-        ty::ty_trait(~ty::TyTrait { def_id, ref substs, store, bounds }) => {
+        ty::ty_trait(box ty::TyTrait {
+                def_id,
+                ref substs,
+                store,
+                bounds
+            }) => {
             mywrite!(w, "x[{}|", (cx.ds)(def_id));
             enc_substs(w, cx, substs);
             enc_trait_store(w, cx, store);
diff --git a/src/librustc/middle/borrowck/doc.rs b/src/librustc/middle/borrowck/doc.rs
index d27d92249fa..886876f82b3 100644
--- a/src/librustc/middle/borrowck/doc.rs
+++ b/src/librustc/middle/borrowck/doc.rs
@@ -68,13 +68,13 @@ niceties. This means that if you have a type like:
 struct S { f: uint }
 ```
 
-and a variable `a: ~S`, then the rust expression `a.f` would correspond
+and a variable `a: Box<S>`, then the rust expression `a.f` would correspond
 to an `LV` of `(*a).f`.
 
 Here is the formal grammar for the types we'll consider:
 
 ```notrust
-TY = () | S<'LT...> | ~TY | & 'LT MQ TY | @ MQ TY
+TY = () | S<'LT...> | Box<TY> | & 'LT MQ TY | @ MQ TY
 MQ = mut | imm | const
 ```
 
@@ -97,7 +97,7 @@ Now, imagine we had a program like this:
 struct Foo { f: uint, g: uint }
 ...
 'a: {
-  let mut x: ~Foo = ...;
+  let mut x: Box<Foo> = ...;
   let y = &mut (*x).f;
   x = ...;
 }
@@ -310,7 +310,7 @@ MUTABILITY(LV.f, MQ)                // M-Field
   MUTABILITY(LV, MQ)
 
 MUTABILITY(*LV, MQ)                 // M-Deref-Unique
-  TYPE(LV) = ~Ty
+  TYPE(LV) = Box<Ty>
   MUTABILITY(LV, MQ)
 ```
 
@@ -420,7 +420,7 @@ The scope of a unique referent is the scope of the pointer, since
 the pointer itself `LV` goes out of scope:
 
 ```notrust
-  SCOPE(*LV) = SCOPE(LV) if LV has type ~T
+  SCOPE(*LV) = SCOPE(LV) if LV has type Box<T>
 ```
 
 The scope of a managed referent is also the scope of the pointer.  This
@@ -459,7 +459,7 @@ LIFETIME(LV.f, LT, MQ)              // L-Field
   LIFETIME(LV, LT, MQ)
 
 LIFETIME(*LV, LT, MQ)               // L-Deref-Send
-  TYPE(LV) = ~Ty
+  TYPE(LV) = Box<Ty>
   LIFETIME(LV, LT, MQ)
 ```
 
@@ -595,7 +595,7 @@ on `LV`:
 
 ```notrust
 RESTRICTIONS(*LV, LT, ACTIONS) = RS, (*LV, ACTIONS)    // R-Deref-Send-Pointer
-  TYPE(LV) = ~Ty
+  TYPE(LV) = Box<Ty>
   RESTRICTIONS(LV, LT, ACTIONS|MUTATE|CLAIM) = RS
 ```
 
@@ -967,8 +967,8 @@ moves/uninitializations of the variable that is being used.
 Let's look at a simple example:
 
 ```
-fn foo(a: ~int) {
-    let b: ~int;       // Gen bit 0.
+fn foo(a: Box<int>) {
+    let b: Box<int>;   // Gen bit 0.
 
     if cond {          // Bits: 0
         use(&*a);
diff --git a/src/librustc/middle/borrowck/mod.rs b/src/librustc/middle/borrowck/mod.rs
index 4efb0e44e8e..96d0d0eaa2f 100644
--- a/src/librustc/middle/borrowck/mod.rs
+++ b/src/librustc/middle/borrowck/mod.rs
@@ -533,7 +533,10 @@ impl<'a> BorrowckCtxt<'a> {
         fn move_suggestion(tcx: &ty::ctxt, ty: ty::t, default_msg: &'static str)
                           -> &'static str {
             match ty::get(ty).sty {
-                ty::ty_closure(~ty::ClosureTy { store: ty::RegionTraitStore(..), .. }) =>
+                ty::ty_closure(box ty::ClosureTy {
+                        store: ty::RegionTraitStore(..),
+                        ..
+                    }) =>
                     "a non-copyable stack closure (capture it in a new closure, \
                      e.g. `|x| f(x)`, to override)",
                 _ if ty::type_moves_by_default(tcx, ty) =>
diff --git a/src/librustc/middle/dataflow.rs b/src/librustc/middle/dataflow.rs
index edbc787fe5c..169a7d32032 100644
--- a/src/librustc/middle/dataflow.rs
+++ b/src/librustc/middle/dataflow.rs
@@ -321,7 +321,7 @@ impl<'a, O:DataFlowOperator+Clone+'static> DataFlowContext<'a, O> {
         });
     }
 
-    fn pretty_print_to(&self, wr: ~io::Writer,
+    fn pretty_print_to(&self, wr: Box<io::Writer>,
                        blk: &ast::Block) -> io::IoResult<()> {
         let mut ps = pprust::rust_printer_annotated(wr, self);
         try!(ps.cbox(pprust::indent_unit));
diff --git a/src/librustc/middle/dead.rs b/src/librustc/middle/dead.rs
index 0638fd5c482..f3a8b9d20d5 100644
--- a/src/librustc/middle/dead.rs
+++ b/src/librustc/middle/dead.rs
@@ -51,7 +51,7 @@ fn should_explore(tcx: &ty::ctxt, def_id: ast::DefId) -> bool {
 struct MarkSymbolVisitor<'a> {
     worklist: Vec<ast::NodeId>,
     tcx: &'a ty::ctxt,
-    live_symbols: ~HashSet<ast::NodeId>,
+    live_symbols: Box<HashSet<ast::NodeId>>,
 }
 
 impl<'a> MarkSymbolVisitor<'a> {
@@ -285,7 +285,7 @@ fn find_live(tcx: &ty::ctxt,
              exported_items: &privacy::ExportedItems,
              reachable_symbols: &NodeSet,
              krate: &ast::Crate)
-             -> ~HashSet<ast::NodeId> {
+             -> Box<HashSet<ast::NodeId>> {
     let worklist = create_and_seed_worklist(tcx, exported_items,
                                             reachable_symbols, krate);
     let mut symbol_visitor = MarkSymbolVisitor::new(tcx, worklist);
@@ -312,7 +312,7 @@ fn get_struct_ctor_id(item: &ast::Item) -> Option<ast::NodeId> {
 
 struct DeadVisitor<'a> {
     tcx: &'a ty::ctxt,
-    live_symbols: ~HashSet<ast::NodeId>,
+    live_symbols: Box<HashSet<ast::NodeId>>,
 }
 
 impl<'a> DeadVisitor<'a> {
diff --git a/src/librustc/middle/kind.rs b/src/librustc/middle/kind.rs
index 92695d7a1d6..402fe822661 100644
--- a/src/librustc/middle/kind.rs
+++ b/src/librustc/middle/kind.rs
@@ -198,11 +198,11 @@ fn with_appropriate_checker(cx: &Context,
 
     let fty = ty::node_id_to_type(cx.tcx, id);
     match ty::get(fty).sty {
-        ty::ty_closure(~ty::ClosureTy {
+        ty::ty_closure(box ty::ClosureTy {
             store: ty::UniqTraitStore, bounds, ..
         }) => b(|cx, fv| check_for_uniq(cx, fv, bounds)),
 
-        ty::ty_closure(~ty::ClosureTy {
+        ty::ty_closure(box ty::ClosureTy {
             store: ty::RegionTraitStore(region, _), bounds, ..
         }) => b(|cx, fv| check_for_block(cx, fv, bounds, region)),
 
@@ -331,7 +331,7 @@ pub fn check_expr(cx: &mut Context, e: &Expr) {
 fn check_trait_cast(cx: &mut Context, source_ty: ty::t, target_ty: ty::t, span: Span) {
     check_cast_for_escaping_regions(cx, source_ty, target_ty, span);
     match ty::get(target_ty).sty {
-        ty::ty_trait(~ty::TyTrait { bounds, .. }) => {
+        ty::ty_trait(box ty::TyTrait { bounds, .. }) => {
             check_trait_cast_bounds(cx, span, source_ty, bounds);
         }
         _ => {}
diff --git a/src/librustc/middle/lint.rs b/src/librustc/middle/lint.rs
index ab1670a6686..3c8ce77fa87 100644
--- a/src/librustc/middle/lint.rs
+++ b/src/librustc/middle/lint.rs
@@ -240,14 +240,14 @@ static lint_table: &'static [(&'static str, LintSpec)] = &[
     ("owned_heap_memory",
      LintSpec {
         lint: OwnedHeapMemory,
-        desc: "use of owned (~ type) heap memory",
+        desc: "use of owned (Box type) heap memory",
         default: allow
      }),
 
     ("heap_memory",
      LintSpec {
         lint: HeapMemory,
-        desc: "use of any (~ type or @ type) heap memory",
+        desc: "use of any (Box type or @ type) heap memory",
         default: allow
      }),
 
@@ -943,8 +943,13 @@ fn check_heap_type(cx: &Context, span: Span, ty: ty::t) {
                     n_box += 1;
                 }
                 ty::ty_uniq(_) |
-                ty::ty_trait(~ty::TyTrait { store: ty::UniqTraitStore, .. }) |
-                ty::ty_closure(~ty::ClosureTy { store: ty::UniqTraitStore, .. }) => {
+                ty::ty_trait(box ty::TyTrait {
+                    store: ty::UniqTraitStore, ..
+                }) |
+                ty::ty_closure(box ty::ClosureTy {
+                    store: ty::UniqTraitStore,
+                    ..
+                }) => {
                     n_uniq += 1;
                 }
 
@@ -955,7 +960,7 @@ fn check_heap_type(cx: &Context, span: Span, ty: ty::t) {
 
         if n_uniq > 0 && lint != ManagedHeapMemory {
             let s = ty_to_str(cx.tcx, ty);
-            let m = format!("type uses owned (~ type) pointers: {}", s);
+            let m = format!("type uses owned (Box type) pointers: {}", s);
             cx.span_lint(lint, span, m);
         }
 
diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs
index b5f31e8b1cd..8ff4430a65b 100644
--- a/src/librustc/middle/mem_categorization.rs
+++ b/src/librustc/middle/mem_categorization.rs
@@ -173,8 +173,8 @@ pub enum deref_kind {
 pub fn opt_deref_kind(t: ty::t) -> Option<deref_kind> {
     match ty::get(t).sty {
         ty::ty_uniq(_) |
-        ty::ty_trait(~ty::TyTrait { store: ty::UniqTraitStore, .. }) |
-        ty::ty_closure(~ty::ClosureTy {store: ty::UniqTraitStore, ..}) => {
+        ty::ty_trait(box ty::TyTrait { store: ty::UniqTraitStore, .. }) |
+        ty::ty_closure(box ty::ClosureTy {store: ty::UniqTraitStore, ..}) => {
             Some(deref_ptr(OwnedPtr))
         }
 
@@ -182,12 +182,18 @@ pub fn opt_deref_kind(t: ty::t) -> Option<deref_kind> {
             let kind = ty::BorrowKind::from_mutbl(mt.mutbl);
             Some(deref_ptr(BorrowedPtr(kind, r)))
         }
-        ty::ty_trait(~ty::TyTrait { store: ty::RegionTraitStore(r, mutbl), .. }) => {
+        ty::ty_trait(box ty::TyTrait {
+                store: ty::RegionTraitStore(r, mutbl),
+                ..
+            }) => {
             let kind = ty::BorrowKind::from_mutbl(mutbl);
             Some(deref_ptr(BorrowedPtr(kind, r)))
         }
 
-        ty::ty_closure(~ty::ClosureTy {store: ty::RegionTraitStore(r, _), ..}) => {
+        ty::ty_closure(box ty::ClosureTy {
+                store: ty::RegionTraitStore(r, _),
+                ..
+            }) => {
             Some(deref_ptr(BorrowedPtr(ty::ImmBorrow, r)))
         }
 
diff --git a/src/librustc/middle/region.rs b/src/librustc/middle/region.rs
index 33db3b44d95..6f42769891e 100644
--- a/src/librustc/middle/region.rs
+++ b/src/librustc/middle/region.rs
@@ -650,7 +650,6 @@ fn resolve_local(visitor: &mut RegionResolutionVisitor,
          *        | VariantName(..., P&, ...)
          *        | [ ..., P&, ... ]
          *        | ( ..., P&, ... )
-         *        | ~P&
          *        | box P&
          */
 
@@ -704,7 +703,7 @@ fn resolve_local(visitor: &mut RegionResolutionVisitor,
          *        | [ ..., E&, ... ]
          *        | ( ..., E&, ... )
          *        | {...; E&}
-         *        | ~E&
+         *        | box E&
          *        | E& as ...
          *        | ( E& )
          */
diff --git a/src/librustc/middle/trans/_match.rs b/src/librustc/middle/trans/_match.rs
index 7206f3f03f5..b456ec224fe 100644
--- a/src/librustc/middle/trans/_match.rs
+++ b/src/librustc/middle/trans/_match.rs
@@ -1155,7 +1155,7 @@ impl<'a> DynamicFailureHandler<'a> {
 enum FailureHandler<'a> {
     Infallible,
     JumpToBasicBlock(BasicBlockRef),
-    DynamicFailureHandlerClass(~DynamicFailureHandler<'a>),
+    DynamicFailureHandlerClass(Box<DynamicFailureHandler<'a>>),
 }
 
 impl<'a> FailureHandler<'a> {
diff --git a/src/librustc/middle/trans/adt.rs b/src/librustc/middle/trans/adt.rs
index ca183e14012..1c955f52037 100644
--- a/src/librustc/middle/trans/adt.rs
+++ b/src/librustc/middle/trans/adt.rs
@@ -248,9 +248,10 @@ pub fn is_ffi_safe(tcx: &ty::ctxt, def_id: ast::DefId) -> bool {
             if hint.is_ffi_safe() {
                 return true;
             }
-            // Option<~T> and similar are used in FFI.  Rather than try to resolve type parameters
-            // and recognize this case exactly, this overapproximates -- assuming that if a
-            // non-C-like enum is being used in FFI then the user knows what they're doing.
+            // Option<Box<T>> and similar are used in FFI.  Rather than try to
+            // resolve type parameters and recognize this case exactly, this
+            // overapproximates -- assuming that if a non-C-like enum is being
+            // used in FFI then the user knows what they're doing.
             if variants.iter().any(|vi| !vi.args.is_empty()) {
                 return true;
             }
diff --git a/src/librustc/middle/trans/cleanup.rs b/src/librustc/middle/trans/cleanup.rs
index 97c9dcce5ef..b9b44b72b10 100644
--- a/src/librustc/middle/trans/cleanup.rs
+++ b/src/librustc/middle/trans/cleanup.rs
@@ -26,6 +26,7 @@ use middle::ty;
 use syntax::ast;
 use util::ppaux::Repr;
 
+
 pub struct CleanupScope<'a> {
     // The id of this cleanup scope. If the id is None,
     // this is a *temporary scope* that is pushed during trans to
@@ -35,7 +36,7 @@ pub struct CleanupScope<'a> {
     kind: CleanupScopeKind<'a>,
 
     // Cleanups to run upon scope exit.
-    cleanups: Vec<~Cleanup>,
+    cleanups: Vec<Box<Cleanup>>,
 
     cached_early_exits: Vec<CachedEarlyExit>,
     cached_landing_pad: Option<BasicBlockRef>,
@@ -248,7 +249,7 @@ impl<'a> CleanupMethods<'a> for FunctionContext<'a> {
                self.ccx.tn.val_to_str(val),
                ty.repr(self.ccx.tcx()));
 
-        self.schedule_clean(cleanup_scope, drop as ~Cleanup);
+        self.schedule_clean(cleanup_scope, drop as Box<Cleanup>);
     }
 
     fn schedule_drop_immediate(&self,
@@ -272,7 +273,7 @@ impl<'a> CleanupMethods<'a> for FunctionContext<'a> {
                self.ccx.tn.val_to_str(val),
                ty.repr(self.ccx.tcx()));
 
-        self.schedule_clean(cleanup_scope, drop as ~Cleanup);
+        self.schedule_clean(cleanup_scope, drop as Box<Cleanup>);
     }
 
     fn schedule_free_value(&self,
@@ -291,12 +292,12 @@ impl<'a> CleanupMethods<'a> for FunctionContext<'a> {
                self.ccx.tn.val_to_str(val),
                heap);
 
-        self.schedule_clean(cleanup_scope, drop as ~Cleanup);
+        self.schedule_clean(cleanup_scope, drop as Box<Cleanup>);
     }
 
     fn schedule_clean(&self,
                       cleanup_scope: ScopeId,
-                      cleanup: ~Cleanup) {
+                      cleanup: Box<Cleanup>) {
         match cleanup_scope {
             AstScope(id) => self.schedule_clean_in_ast_scope(id, cleanup),
             CustomScope(id) => self.schedule_clean_in_custom_scope(id, cleanup),
@@ -305,7 +306,7 @@ impl<'a> CleanupMethods<'a> for FunctionContext<'a> {
 
     fn schedule_clean_in_ast_scope(&self,
                                    cleanup_scope: ast::NodeId,
-                                   cleanup: ~Cleanup) {
+                                   cleanup: Box<Cleanup>) {
         /*!
          * Schedules a cleanup to occur upon exit from `cleanup_scope`.
          * If `cleanup_scope` is not provided, then the cleanup is scheduled
@@ -333,7 +334,7 @@ impl<'a> CleanupMethods<'a> for FunctionContext<'a> {
 
     fn schedule_clean_in_custom_scope(&self,
                                       custom_scope: CustomScopeIndex,
-                                      cleanup: ~Cleanup) {
+                                      cleanup: Box<Cleanup>) {
         /*!
          * Schedules a cleanup to occur in the top-most scope,
          * which must be a temporary scope.
@@ -909,13 +910,13 @@ pub trait CleanupMethods<'a> {
                            heap: Heap);
     fn schedule_clean(&self,
                       cleanup_scope: ScopeId,
-                      cleanup: ~Cleanup);
+                      cleanup: Box<Cleanup>);
     fn schedule_clean_in_ast_scope(&self,
                                    cleanup_scope: ast::NodeId,
-                                   cleanup: ~Cleanup);
+                                   cleanup: Box<Cleanup>);
     fn schedule_clean_in_custom_scope(&self,
                                     custom_scope: CustomScopeIndex,
-                                    cleanup: ~Cleanup);
+                                    cleanup: Box<Cleanup>);
     fn needs_invoke(&self) -> bool;
     fn get_landing_pad(&'a self) -> BasicBlockRef;
 }
diff --git a/src/librustc/middle/trans/debuginfo.rs b/src/librustc/middle/trans/debuginfo.rs
index e8654da3457..049a6930ab9 100644
--- a/src/librustc/middle/trans/debuginfo.rs
+++ b/src/librustc/middle/trans/debuginfo.rs
@@ -57,7 +57,7 @@ For example, the following simple type for a singly-linked list...
 ```
 struct List {
     value: int,
-    tail: Option<~List>,
+    tail: Option<Box<List>>,
 }
 ```
 
@@ -66,8 +66,8 @@ will generate the following callstack with a naive DFS algorithm:
 ```
 describe(t = List)
   describe(t = int)
-  describe(t = Option<~List>)
-    describe(t = ~List)
+  describe(t = Option<Box<List>>)
+    describe(t = Box<List>)
       describe(t = List) // at the beginning again...
       ...
 ```
@@ -211,7 +211,7 @@ pub struct FunctionDebugContext {
 }
 
 enum FunctionDebugContextRepr {
-    FunctionDebugContext(~FunctionDebugContextData),
+    FunctionDebugContext(Box<FunctionDebugContextData>),
     DebugInfoDisabled,
     FunctionWithoutDebugInfo,
 }
@@ -219,7 +219,7 @@ enum FunctionDebugContextRepr {
 impl FunctionDebugContext {
     fn get_ref<'a>(&'a self, cx: &CrateContext, span: Span) -> &'a FunctionDebugContextData {
         match self.repr {
-            FunctionDebugContext(~ref data) => data,
+            FunctionDebugContext(box ref data) => data,
             DebugInfoDisabled => {
                 cx.sess().span_bug(span, FunctionDebugContext::debuginfo_disabled_message());
             }
@@ -560,7 +560,7 @@ pub fn set_source_location(fcx: &FunctionContext,
             set_debug_location(fcx.ccx, UnknownLocation);
             return;
         }
-        FunctionDebugContext(~ref function_debug_context) => {
+        FunctionDebugContext(box ref function_debug_context) => {
             let cx = fcx.ccx;
 
             debug!("set_source_location: {}", cx.sess().codemap().span_to_str(span));
@@ -596,7 +596,7 @@ pub fn clear_source_location(fcx: &FunctionContext) {
 /// translated.
 pub fn start_emitting_source_locations(fcx: &FunctionContext) {
     match fcx.debug_context.repr {
-        FunctionDebugContext(~ref data) => {
+        FunctionDebugContext(box ref data) => {
             data.source_locations_enabled.set(true)
         },
         _ => { /* safe to ignore */ }
@@ -2227,7 +2227,12 @@ fn type_metadata(cx: &CrateContext,
         ty::ty_closure(ref closurety) => {
             subroutine_type_metadata(cx, &closurety.sig, usage_site_span)
         }
-        ty::ty_trait(~ty::TyTrait { def_id, ref substs, store, ref bounds }) => {
+        ty::ty_trait(box ty::TyTrait {
+                def_id,
+                ref substs,
+                store,
+                ref bounds
+            }) => {
             trait_metadata(cx, def_id, t, substs, store, bounds)
         }
         ty::ty_struct(def_id, ref substs) => {
diff --git a/src/librustc/middle/trans/doc.rs b/src/librustc/middle/trans/doc.rs
index d6dda75c7c0..56bf2561338 100644
--- a/src/librustc/middle/trans/doc.rs
+++ b/src/librustc/middle/trans/doc.rs
@@ -31,7 +31,7 @@ expression functions depending on the kind of expression. We divide
 up expressions into:
 
 - **Datum expressions:** Those that most naturally yield values.
-  Examples would be `22`, `~x`, or `a + b` (when not overloaded).
+  Examples would be `22`, `box x`, or `a + b` (when not overloaded).
 - **DPS expressions:** Those that most naturally write into a location
   in memory. Examples would be `foo()` or `Point { x: 3, y: 4 }`.
 - **Statement expressions:** That that do not generate a meaningful
@@ -107,7 +107,7 @@ Somewhat surprisingly, not all lvalue expressions yield lvalue datums
 when trans'd. Ultimately the reason for this is to micro-optimize
 the resulting LLVM. For example, consider the following code:
 
-    fn foo() -> ~int { ... }
+    fn foo() -> Box<int> { ... }
     let x = *foo();
 
 The expression `*foo()` is an lvalue, but if you invoke `expr::trans`,
@@ -169,7 +169,7 @@ is fully initialized, then the cleanup will run and try to free or
 drop uninitialized memory. If the initialization itself produces
 byproducts that need to be freed, then you should use temporary custom
 scopes to ensure that those byproducts will get freed on unwind.  For
-example, an expression like `~foo()` will first allocate a box in the
+example, an expression like `box foo()` will first allocate a box in the
 heap and then call `foo()` -- if `foo()` should fail, this box needs
 to be *shallowly* freed.
 
@@ -219,11 +219,11 @@ unwind, and only up until the point where execution succeeded, at
 which time the complete value should be stored in an lvalue or some
 other place where normal cleanup applies.
 
-To spell it out, here is an example. Imagine an expression `~expr`.
+To spell it out, here is an example. Imagine an expression `box expr`.
 We would basically:
 
 1. Push a custom cleanup scope C.
-2. Allocate the `~` box.
+2. Allocate the box.
 3. Schedule a shallow free in the scope C.
 4. Trans `expr` into the box.
 5. Pop the scope C.
diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs
index 2e8c60c5dc5..806fb3e125d 100644
--- a/src/librustc/middle/trans/expr.rs
+++ b/src/librustc/middle/trans/expr.rs
@@ -397,8 +397,8 @@ fn trans_datum_unadjusted<'a>(bcx: &'a Block<'a>,
             DatumBlock(bcx, datum)
         }
         ast::ExprBox(_, contents) => {
-            // Special case for `~T`. (The other case, for GC, is handled in
-            // `trans_rvalue_dps_unadjusted`.)
+            // Special case for `box T`. (The other case, for GC, is handled
+            // in `trans_rvalue_dps_unadjusted`.)
             let box_ty = expr_ty(bcx, expr);
             let contents_ty = expr_ty(bcx, contents);
             trans_uniq_expr(bcx, box_ty, contents, contents_ty)
@@ -1171,11 +1171,12 @@ fn trans_uniq_expr<'a>(bcx: &'a Block<'a>,
     let llty = type_of::type_of(bcx.ccx(), contents_ty);
     let size = llsize_of(bcx.ccx(), llty);
     // We need to a make a pointer type because box_ty is ty_bot
-    // if content_ty is, e.g. ~fail!().
+    // if content_ty is, e.g. box fail!().
     let real_box_ty = ty::mk_uniq(bcx.tcx(), contents_ty);
     let Result { bcx, val } = malloc_raw_dyn(bcx, real_box_ty, size);
-    // Unique boxes do not allocate for zero-size types. The standard library may assume
-    // that `free` is never called on the pointer returned for `~ZeroSizeType`.
+    // Unique boxes do not allocate for zero-size types. The standard library
+    // may assume that `free` is never called on the pointer returned for
+    // `Box<ZeroSizeType>`.
     let bcx = if llsize_of_alloc(bcx.ccx(), llty) == 0 {
         trans_into(bcx, contents, SaveIn(val))
     } else {
@@ -1774,8 +1775,8 @@ fn deref_once<'a>(bcx: &'a Block<'a>,
          * Basically, the idea is to make the deref of an rvalue
          * result in an rvalue. This helps to avoid intermediate stack
          * slots in the resulting LLVM. The idea here is that, if the
-         * `~T` pointer is an rvalue, then we can schedule a *shallow*
-         * free of the `~T` pointer, and then return a ByRef rvalue
+         * `Box<T>` pointer is an rvalue, then we can schedule a *shallow*
+         * free of the `Box<T>` pointer, and then return a ByRef rvalue
          * into the pointer. Because the free is shallow, it is legit
          * to return an rvalue, because we know that the contents are
          * not yet scheduled to be freed. The language rules ensure that the
diff --git a/src/librustc/middle/trans/glue.rs b/src/librustc/middle/trans/glue.rs
index 37a387a558f..1bde80815c3 100644
--- a/src/librustc/middle/trans/glue.rs
+++ b/src/librustc/middle/trans/glue.rs
@@ -89,7 +89,7 @@ fn get_drop_glue_type(ccx: &CrateContext, t: ty::t) -> ty::t {
                     let llty = sizing_type_of(ccx, typ);
                     // Unique boxes do not allocate for zero-size types. The standard
                     // library may assume that `free` is never called on the pointer
-                    // returned for `~ZeroSizeType`.
+                    // returned for `Box<ZeroSizeType>`.
                     if llsize_of_alloc(ccx, llty) == 0 {
                         ty::mk_i8()
                     } else {
@@ -318,7 +318,7 @@ fn make_drop_glue<'a>(bcx: &'a Block<'a>, v0: ValueRef, t: ty::t) -> &'a Block<'
                 }
             }
         }
-        ty::ty_trait(~ty::TyTrait { store: ty::UniqTraitStore, .. }) => {
+        ty::ty_trait(box ty::TyTrait { store: ty::UniqTraitStore, .. }) => {
             let lluniquevalue = GEPi(bcx, v0, [0, abi::trt_field_box]);
             // Only drop the value when it is non-null
             with_cond(bcx, IsNotNull(bcx, Load(bcx, lluniquevalue)), |bcx| {
diff --git a/src/librustc/middle/trans/meth.rs b/src/librustc/middle/trans/meth.rs
index d122edb7678..b13444a4410 100644
--- a/src/librustc/middle/trans/meth.rs
+++ b/src/librustc/middle/trans/meth.rs
@@ -344,7 +344,7 @@ fn trans_trait_callee<'a>(bcx: &'a Block<'a>,
                           -> Callee<'a> {
     /*!
      * Create a method callee where the method is coming from a trait
-     * object (e.g., ~Trait type).  In this case, we must pull the fn
+     * object (e.g., Box<Trait> type).  In this case, we must pull the fn
      * pointer out of the vtable that is packaged up with the object.
      * Objects are represented as a pair, so we first evaluate the self
      * expression and then extract the self data and vtable out of the
@@ -401,7 +401,7 @@ pub fn trans_trait_callee_from_llval<'a>(bcx: &'a Block<'a>,
 
     // Load the function from the vtable and cast it to the expected type.
     debug!("(translating trait callee) loading method");
-    // Replace the self type (&Self or ~Self) with an opaque pointer.
+    // Replace the self type (&Self or Box<Self>) with an opaque pointer.
     let llcallee_ty = match ty::get(callee_ty).sty {
         ty::ty_bare_fn(ref f) if f.abi == Rust => {
             type_of_rust_fn(ccx, true, f.sig.inputs.slice_from(1), f.sig.output)
@@ -527,8 +527,8 @@ pub fn trans_trait_cast<'a>(bcx: &'a Block<'a>,
                             dest: expr::Dest)
                             -> &'a Block<'a> {
     /*!
-     * Generates the code to convert from a pointer (`~T`, `&T`, etc)
-     * into an object (`~Trait`, `&Trait`, etc). This means creating a
+     * Generates the code to convert from a pointer (`Box<T>`, `&T`, etc)
+     * into an object (`Box<Trait>`, `&Trait`, etc). This means creating a
      * pair where the first word is the vtable and the second word is
      * the pointer.
      */
diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs
index 89d93bb3111..461d39240e8 100644
--- a/src/librustc/middle/ty.rs
+++ b/src/librustc/middle/ty.rs
@@ -128,7 +128,7 @@ pub struct mt {
 
 #[deriving(Clone, Eq, TotalEq, Hash, Encodable, Decodable, Show)]
 pub enum TraitStore {
-    /// ~Trait
+    /// Box<Trait>
     UniqTraitStore,
     /// &Trait and &mut Trait
     RegionTraitStore(Region, ast::Mutability),
@@ -229,7 +229,7 @@ pub enum AutoRef {
     /// Convert from T to *T
     AutoUnsafe(ast::Mutability),
 
-    /// Convert from ~Trait/&Trait to &Trait
+    /// Convert from Box<Trait>/&Trait to &Trait
     AutoBorrowObj(Region, ast::Mutability),
 }
 
@@ -239,7 +239,7 @@ pub enum AutoRef {
 pub struct ctxt {
     // Specifically use a speedy hash algorithm for this hash map, it's used
     // quite often.
-    pub interner: RefCell<FnvHashMap<intern_key, ~t_box_>>,
+    pub interner: RefCell<FnvHashMap<intern_key, Box<t_box_>>>,
     pub next_id: Cell<uint>,
     pub sess: Session,
     pub def_map: resolve::DefMap,
@@ -735,8 +735,8 @@ pub enum sty {
     ty_ptr(mt),
     ty_rptr(Region, mt),
     ty_bare_fn(BareFnTy),
-    ty_closure(~ClosureTy),
-    ty_trait(~TyTrait),
+    ty_closure(Box<ClosureTy>),
+    ty_trait(Box<TyTrait>),
     ty_struct(DefId, substs),
     ty_tup(Vec<t>),
 
@@ -1195,7 +1195,7 @@ pub fn mk_t(cx: &ctxt, st: sty) -> t {
       &ty_enum(_, ref substs) | &ty_struct(_, ref substs) => {
           flags |= sflags(substs);
       }
-      &ty_trait(~ty::TyTrait { ref substs, store, .. }) => {
+      &ty_trait(box ty::TyTrait { ref substs, store, .. }) => {
           flags |= sflags(substs);
           match store {
               RegionTraitStore(r, _) => {
@@ -1482,7 +1482,7 @@ pub fn maybe_walk_ty(ty: t, f: |t| -> bool) {
             maybe_walk_ty(tm.ty, f);
         }
         ty_enum(_, ref substs) | ty_struct(_, ref substs) |
-        ty_trait(~TyTrait { ref substs, .. }) => {
+        ty_trait(box TyTrait { ref substs, .. }) => {
             for subty in (*substs).tps.iter() { maybe_walk_ty(*subty, |x| f(x)); }
         }
         ty_tup(ref ts) => { for tt in ts.iter() { maybe_walk_ty(*tt, |x| f(x)); } }
@@ -1951,7 +1951,7 @@ impl TypeContents {
     pub fn owned_pointer(&self) -> TypeContents {
         /*!
          * Includes only those bits that still apply
-         * when indirected through a `~` pointer
+         * when indirected through a `Box` pointer
          */
         TC::OwnsOwned | (
             *self & (TC::OwnsAll | TC::ReachesAll))
@@ -2050,7 +2050,7 @@ pub fn type_contents(cx: &ctxt, ty: t) -> TypeContents {
         // private cache for this walk.  This is needed in the case of cyclic
         // types like:
         //
-        //     struct List { next: ~Option<List>, ... }
+        //     struct List { next: Box<Option<List>>, ... }
         //
         // When computing the type contents of such a type, we wind up deeply
         // recursing as we go.  So when we encounter the recursive reference
@@ -2100,7 +2100,7 @@ pub fn type_contents(cx: &ctxt, ty: t) -> TypeContents {
                 }
             }
 
-            ty_trait(~ty::TyTrait { store, bounds, .. }) => {
+            ty_trait(box ty::TyTrait { store, bounds, .. }) => {
                 object_contents(cx, store, bounds)
             }
 
@@ -2965,7 +2965,7 @@ pub fn adjust_ty(cx: &ctxt,
     fn borrow_obj(cx: &ctxt, span: Span, r: Region,
                   m: ast::Mutability, ty: ty::t) -> ty::t {
         match get(ty).sty {
-            ty_trait(~ty::TyTrait {def_id, ref substs, bounds, .. }) => {
+            ty_trait(box ty::TyTrait {def_id, ref substs, bounds, .. }) => {
                 ty::mk_trait(cx, def_id, substs.clone(),
                              RegionTraitStore(r, m), bounds)
             }
@@ -3164,7 +3164,7 @@ pub fn expr_kind(tcx: &ctxt, expr: &ast::Expr) -> ExprKind {
                     // writing) it's not easy to distinguish casts to traits
                     // from other casts based on the AST.  This should be
                     // easier in the future, when casts to traits
-                    // would like @Foo, ~Foo, or &Foo.
+                    // would like @Foo, Box<Foo>, or &Foo.
                     RvalueDatumExpr
                 }
             }
@@ -3192,7 +3192,7 @@ pub fn expr_kind(tcx: &ctxt, expr: &ast::Expr) -> ExprKind {
         }
 
         ast::ExprBox(place, _) => {
-            // Special case `~T` for now:
+            // Special case `Box<T>` for now:
             let definition = match tcx.def_map.borrow().find(&place.id) {
                 Some(&def) => def,
                 None => fail!("no def for place"),
@@ -3264,7 +3264,7 @@ pub fn ty_sort_str(cx: &ctxt, t: t) -> ~str {
 
         ty_enum(id, _) => format!("enum {}", item_path_str(cx, id)),
         ty_box(_) => "@-ptr".to_owned(),
-        ty_uniq(_) => "~-ptr".to_owned(),
+        ty_uniq(_) => "box".to_owned(),
         ty_vec(_, _) => "vector".to_owned(),
         ty_ptr(_) => "*-ptr".to_owned(),
         ty_rptr(_, _) => "&-ptr".to_owned(),
@@ -3614,7 +3614,9 @@ pub fn try_add_builtin_trait(tcx: &ctxt,
 
 pub fn ty_to_def_id(ty: t) -> Option<ast::DefId> {
     match get(ty).sty {
-        ty_trait(~TyTrait { def_id: id, .. }) | ty_struct(id, _) | ty_enum(id, _) => Some(id),
+        ty_trait(box TyTrait { def_id: id, .. }) |
+        ty_struct(id, _) |
+        ty_enum(id, _) => Some(id),
         _ => None
     }
 }
@@ -4575,7 +4577,7 @@ pub fn hash_crate_independent(tcx: &ctxt, t: t, svh: &Svh) -> u64 {
                     }
                 }
             }
-            ty_trait(~ty::TyTrait { def_id: d, store, bounds, .. }) => {
+            ty_trait(box ty::TyTrait { def_id: d, store, bounds, .. }) => {
                 byte!(17);
                 did(&mut state, d);
                 match store {
diff --git a/src/librustc/middle/ty_fold.rs b/src/librustc/middle/ty_fold.rs
index f8f9ca30712..4b0153b67ff 100644
--- a/src/librustc/middle/ty_fold.rs
+++ b/src/librustc/middle/ty_fold.rs
@@ -149,8 +149,13 @@ pub fn super_fold_sty<T:TypeFolder>(this: &mut T,
         ty::ty_enum(tid, ref substs) => {
             ty::ty_enum(tid, this.fold_substs(substs))
         }
-        ty::ty_trait(~ty::TyTrait { def_id, ref substs, store, bounds }) => {
-            ty::ty_trait(box ty::TyTrait{
+        ty::ty_trait(box ty::TyTrait {
+                def_id,
+                ref substs,
+                store,
+                bounds
+            }) => {
+            ty::ty_trait(box ty::TyTrait {
                 def_id: def_id,
                 substs: this.fold_substs(substs),
                 store: this.fold_trait_store(store),
diff --git a/src/librustc/middle/typeck/astconv.rs b/src/librustc/middle/typeck/astconv.rs
index 1c5bea04a87..e3591af6440 100644
--- a/src/librustc/middle/typeck/astconv.rs
+++ b/src/librustc/middle/typeck/astconv.rs
@@ -876,7 +876,8 @@ fn conv_builtin_bounds(tcx: &ty::ctxt, ast_bounds: &Option<OwnedSlice<ast::TyPar
     //! legal.
     //! If no bounds were specified, we choose a "default" bound based on
     //! the allocation type of the fn/trait, as per issue #7264. The user can
-    //! override this with an empty bounds list, e.g. "~fn:()" or "~Trait:".
+    //! override this with an empty bounds list, e.g. "Box<fn:()>" or
+    //! "Box<Trait:>".
 
     match (ast_bounds, store) {
         (&Some(ref bound_vec), _) => {
diff --git a/src/librustc/middle/typeck/check/_match.rs b/src/librustc/middle/typeck/check/_match.rs
index 9c8e02b8e21..e6a6a370b13 100644
--- a/src/librustc/middle/typeck/check/_match.rs
+++ b/src/librustc/middle/typeck/check/_match.rs
@@ -691,7 +691,7 @@ pub fn check_pat(pcx: &pat_ctxt, pat: &ast::Pat, expected: ty::t) {
     }
 }
 
-// Helper function to check @, ~ and & patterns
+// Helper function to check @, box and & patterns
 pub fn check_pointer_pat(pcx: &pat_ctxt,
                          pointer_kind: PointerKind,
                          inner: &ast::Pat,
@@ -721,7 +721,7 @@ pub fn check_pointer_pat(pcx: &pat_ctxt,
                              e, actual)})},
                 Some(expected),
                 format!("{} pattern", match pointer_kind {
-                    Send => "a `~`-box",
+                    Send => "a box",
                     Borrowed => "an `&`-pointer"
                 }),
                 None);
diff --git a/src/librustc/middle/typeck/check/method.rs b/src/librustc/middle/typeck/check/method.rs
index 9234270cf7e..17a432d2b5d 100644
--- a/src/librustc/middle/typeck/check/method.rs
+++ b/src/librustc/middle/typeck/check/method.rs
@@ -30,7 +30,7 @@ itself (note that inherent impls can only be defined in the same
 module as the type itself).
 
 Inherent candidates are not always derived from impls.  If you have a
-trait instance, such as a value of type `~ToStr`, then the trait
+trait instance, such as a value of type `Box<ToStr>`, then the trait
 methods (`to_str()`, in this case) are inherently associated with it.
 Another case is type parameters, in which case the methods of their
 bounds are inherent.
@@ -72,9 +72,9 @@ Both the inherent candidate collection and the candidate selection
 proceed by progressively deref'ing the receiver type, after all.  The
 answer is that two phases are needed to elegantly deal with explicit
 self.  After all, if there is an impl for the type `Foo`, it can
-define a method with the type `~self`, which means that it expects a
-receiver of type `~Foo`.  If we have a receiver of type `~Foo`, but we
-waited to search for that impl until we have deref'd the `~` away and
+define a method with the type `Box<self>`, which means that it expects a
+receiver of type `Box<Foo>`.  If we have a receiver of type `Box<Foo>`, but we
+waited to search for that impl until we have deref'd the `Box` away and
 obtained the type `Foo`, we would never match this method.
 
 */
@@ -243,15 +243,15 @@ fn construct_transformed_self_ty_for_object(
         *
         *     trait Foo {
         *         fn r_method<'a>(&'a self);
-        *         fn u_method(~self);
+        *         fn u_method(Box<self>);
         *     }
         *
         * Now, assuming that `r_method` is being called, we want the
         * result to be `&'a Foo`. Assuming that `u_method` is being
-        * called, we want the result to be `~Foo`. Of course,
+        * called, we want the result to be `Box<Foo>`. Of course,
         * this transformation has already been done as part of
         * `method_ty.fty.sig.inputs[0]`, but there the type
-        * is expressed in terms of `Self` (i.e., `&'a Self`, `~Self`).
+        * is expressed in terms of `Self` (i.e., `&'a Self`, `Box<Self>`).
         * Because objects are not standalone types, we can't just substitute
         * `s/Self/Foo/`, so we must instead perform this kind of hokey
         * match below.
@@ -328,8 +328,8 @@ struct Candidate {
 /// considered to "match" a given method candidate. Typically the test
 /// is whether the receiver is of a particular type. However, this
 /// type is the type of the receiver *after accounting for the
-/// method's self type* (e.g., if the method is an `~self` method, we
-/// have *already verified* that the receiver is of some type `~T` and
+/// method's self type* (e.g., if the method is an `Box<self>` method, we
+/// have *already verified* that the receiver is of some type `Box<T>` and
 /// now we must check that the type `T` is correct).  Unfortunately,
 /// because traits are not types, this is a pain to do.
 #[deriving(Clone)]
@@ -421,14 +421,14 @@ impl<'a> LookupContext<'a> {
          * `self.inherent_candidates`.  See comment at the start of
          * the file.  To find the inherent candidates, we repeatedly
          * deref the self-ty to find the "base-type".  So, for
-         * example, if the receiver is ~~C where `C` is a struct type,
+         * example, if the receiver is Box<Box<C>> where `C` is a struct type,
          * we'll want to find the inherent impls for `C`.
          */
 
         let span = self.self_expr.map_or(self.span, |e| e.span);
         check::autoderef(self.fcx, span, self_ty, None, PreferMutLvalue, |self_ty, _| {
             match get(self_ty).sty {
-                ty_trait(~TyTrait { def_id, ref substs, .. }) => {
+                ty_trait(box TyTrait { def_id, ref substs, .. }) => {
                     self.push_inherent_candidates_from_object(def_id, substs);
                     self.push_inherent_impl_candidates_for_type(def_id);
                 }
@@ -767,9 +767,9 @@ impl<'a> LookupContext<'a> {
          * consuming the original pointer.
          *
          * You might think that this would be a natural byproduct of
-         * the auto-deref/auto-ref process.  This is true for `~T`
-         * but not for an `&mut T` receiver.  With `~T`, we would
-         * begin by testing for methods with a self type `~T`,
+         * the auto-deref/auto-ref process.  This is true for `Box<T>`
+         * but not for an `&mut T` receiver.  With `Box<T>`, we would
+         * begin by testing for methods with a self type `Box<T>`,
          * then autoderef to `T`, then autoref to `&mut T`.  But with
          * an `&mut T` receiver the process begins with `&mut T`, only
          * without any autoadjustments.
@@ -797,7 +797,7 @@ impl<'a> LookupContext<'a> {
                      autoref: Some(auto)})
             }
 
-            ty::ty_trait(~ty::TyTrait {
+            ty::ty_trait(box ty::TyTrait {
                 def_id, ref substs, store: ty::RegionTraitStore(_, mutbl), bounds
             }) => {
                 let region =
@@ -902,8 +902,13 @@ impl<'a> LookupContext<'a> {
             },
             ty_vec(mt, Some(_)) => self.auto_slice_vec(mt, autoderefs),
 
-            ty_trait(~ty::TyTrait { def_id: trt_did, substs: trt_substs, bounds: b, .. }) => {
-                // Coerce ~/&Trait instances to &Trait.
+            ty_trait(box ty::TyTrait {
+                    def_id: trt_did,
+                    substs: trt_substs,
+                    bounds: b,
+                    ..
+                }) => {
+                // Coerce Box/&Trait instances to &Trait.
 
                 self.search_for_some_kind_of_autorefd_method(
                     AutoBorrowObj, autoderefs, [MutImmutable, MutMutable],
@@ -1361,7 +1366,7 @@ impl<'a> LookupContext<'a> {
                         }
                     }
 
-                    ty::ty_trait(~ty::TyTrait {
+                    ty::ty_trait(box ty::TyTrait {
                         def_id: self_did, store: RegionTraitStore(_, self_m), ..
                     }) => {
                         mutability_matches(self_m, m) &&
@@ -1382,7 +1387,7 @@ impl<'a> LookupContext<'a> {
                         }
                     }
 
-                    ty::ty_trait(~ty::TyTrait {
+                    ty::ty_trait(box ty::TyTrait {
                         def_id: self_did, store: UniqTraitStore, ..
                     }) => {
                         rcvr_matches_object(self_did, candidate)
diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs
index f934f0805e6..c352ba7e3a5 100644
--- a/src/librustc/middle/typeck/check/mod.rs
+++ b/src/librustc/middle/typeck/check/mod.rs
@@ -1912,7 +1912,7 @@ fn check_expr_with_unifier(fcx: &FnCtxt,
 
         let fn_sig = match *fn_sty {
             ty::ty_bare_fn(ty::BareFnTy {sig: ref sig, ..}) |
-            ty::ty_closure(~ty::ClosureTy {sig: ref sig, ..}) => sig,
+            ty::ty_closure(box ty::ClosureTy {sig: ref sig, ..}) => sig,
             _ => {
                 fcx.type_error_message(call_expr.span, |actual| {
                     format!("expected function but \
diff --git a/src/librustc/middle/typeck/check/regionck.rs b/src/librustc/middle/typeck/check/regionck.rs
index 0250cc0a5ed..4c36a935dee 100644
--- a/src/librustc/middle/typeck/check/regionck.rs
+++ b/src/librustc/middle/typeck/check/regionck.rs
@@ -367,7 +367,7 @@ fn constrain_bindings_in_pat(pat: &ast::Pat, rcx: &mut Rcx) {
         // accessed. We must be wary of loops like this:
         //
         //     // from src/test/compile-fail/borrowck-lend-flow.rs
-        //     let mut v = ~3, w = ~4;
+        //     let mut v = box 3, w = box 4;
         //     let mut x = &mut w;
         //     loop {
         //         **x += 1;   // (2)
@@ -539,7 +539,7 @@ fn visit_expr(rcx: &mut Rcx, expr: &ast::Expr) {
             // explaining how it goes about doing that.
             let target_ty = rcx.resolve_node_type(expr.id);
             match ty::get(target_ty).sty {
-                ty::ty_trait(~ty::TyTrait {
+                ty::ty_trait(box ty::TyTrait {
                     store: ty::RegionTraitStore(trait_region, _), ..
                 }) => {
                     let source_ty = rcx.resolve_expr_type_adjusted(source);
@@ -609,7 +609,7 @@ fn check_expr_fn_block(rcx: &mut Rcx,
     let tcx = rcx.fcx.tcx();
     let function_type = rcx.resolve_node_type(expr.id);
     match ty::get(function_type).sty {
-        ty::ty_closure(~ty::ClosureTy {
+        ty::ty_closure(box ty::ClosureTy {
                 store: ty::RegionTraitStore(region, _), ..}) => {
             freevars::with_freevars(tcx, expr.id, |freevars| {
                 if freevars.is_empty() {
@@ -635,7 +635,10 @@ fn check_expr_fn_block(rcx: &mut Rcx,
     rcx.set_repeating_scope(repeating_scope);
 
     match ty::get(function_type).sty {
-        ty::ty_closure(~ty::ClosureTy {store: ty::RegionTraitStore(..), ..}) => {
+        ty::ty_closure(box ty::ClosureTy {
+                store: ty::RegionTraitStore(..),
+                ..
+            }) => {
             freevars::with_freevars(tcx, expr.id, |freevars| {
                 propagate_upupvar_borrow_kind(rcx, expr, freevars);
             })
diff --git a/src/librustc/middle/typeck/check/vtable.rs b/src/librustc/middle/typeck/check/vtable.rs
index 8b3794aff72..192c67eb8d1 100644
--- a/src/librustc/middle/typeck/check/vtable.rs
+++ b/src/librustc/middle/typeck/check/vtable.rs
@@ -532,7 +532,7 @@ pub fn early_resolve_expr(ex: &ast::Expr, fcx: &FnCtxt, is_early: bool) {
     let resolve_object_cast = |src: &ast::Expr, target_ty: ty::t| {
       match ty::get(target_ty).sty {
           // Bounds of type's contents are not checked here, but in kind.rs.
-          ty::ty_trait(~ty::TyTrait {
+          ty::ty_trait(box ty::TyTrait {
               def_id: target_def_id, substs: ref target_substs, store, ..
           }) => {
               fn mutability_allowed(a_mutbl: ast::Mutability,
@@ -543,7 +543,7 @@ pub fn early_resolve_expr(ex: &ast::Expr, fcx: &FnCtxt, is_early: bool) {
               // Look up vtables for the type we're casting to,
               // passing in the source and target type.  The source
               // must be a pointer type suitable to the object sigil,
-              // e.g.: `&x as &Trait` or `~x as ~Trait`
+              // e.g.: `&x as &Trait` or `box x as Box<Trait>`
               let ty = structurally_resolved_type(fcx, ex.span,
                                                   fcx.expr_ty(src));
               match (&ty::get(ty).sty, store) {
@@ -606,8 +606,8 @@ pub fn early_resolve_expr(ex: &ast::Expr, fcx: &FnCtxt, is_early: bool) {
                   (_, ty::UniqTraitStore) => {
                       fcx.ccx.tcx.sess.span_err(
                           ex.span,
-                          format!("can only cast an ~-pointer \
-                                to a ~-object, not a {}",
+                          format!("can only cast an boxed pointer \
+                                   to a boxed object, not a {}",
                                ty::ty_sort_str(fcx.tcx(), ty)));
                   }
 
diff --git a/src/librustc/middle/typeck/coherence.rs b/src/librustc/middle/typeck/coherence.rs
index 3a50b0681e8..c15c30656ad 100644
--- a/src/librustc/middle/typeck/coherence.rs
+++ b/src/librustc/middle/typeck/coherence.rs
@@ -103,7 +103,7 @@ fn type_is_defined_in_local_crate(original_type: t) -> bool {
     ty::walk_ty(original_type, |t| {
         match get(t).sty {
             ty_enum(def_id, _) |
-            ty_trait(~ty::TyTrait { def_id, .. }) |
+            ty_trait(box ty::TyTrait { def_id, .. }) |
             ty_struct(def_id, _) => {
                 if def_id.krate == ast::LOCAL_CRATE {
                     found_nominal = true;
@@ -129,7 +129,7 @@ fn get_base_type_def_id(inference_context: &InferCtxt,
             match get(base_type).sty {
                 ty_enum(def_id, _) |
                 ty_struct(def_id, _) |
-                ty_trait(~ty::TyTrait { def_id, .. }) => {
+                ty_trait(box ty::TyTrait { def_id, .. }) => {
                     return Some(def_id);
                 }
                 _ => {
diff --git a/src/librustc/middle/typeck/infer/coercion.rs b/src/librustc/middle/typeck/infer/coercion.rs
index aa00b24474f..d50e36c31a0 100644
--- a/src/librustc/middle/typeck/infer/coercion.rs
+++ b/src/librustc/middle/typeck/infer/coercion.rs
@@ -121,7 +121,10 @@ impl<'f> Coerce<'f> {
                 };
             }
 
-            ty::ty_closure(~ty::ClosureTy {store: ty::RegionTraitStore(..), ..}) => {
+            ty::ty_closure(box ty::ClosureTy {
+                    store: ty::RegionTraitStore(..),
+                    ..
+                }) => {
                 return self.unpack_actual_value(a, |sty_a| {
                     self.coerce_borrowed_fn(a, sty_a, b)
                 });
@@ -133,7 +136,7 @@ impl<'f> Coerce<'f> {
                 });
             }
 
-            ty::ty_trait(~ty::TyTrait {
+            ty::ty_trait(box ty::TyTrait {
                 def_id, ref substs, store: ty::UniqTraitStore, bounds
             }) => {
                 let result = self.unpack_actual_value(a, |sty_a| {
@@ -152,7 +155,7 @@ impl<'f> Coerce<'f> {
                 }
             }
 
-            ty::ty_trait(~ty::TyTrait {
+            ty::ty_trait(box ty::TyTrait {
                 def_id, ref substs, store: ty::RegionTraitStore(region, m), bounds
             }) => {
                 let result = self.unpack_actual_value(a, |sty_a| {
@@ -332,7 +335,12 @@ impl<'f> Coerce<'f> {
         let r_a = self.get_ref().infcx.next_region_var(coercion);
 
         let a_borrowed = match *sty_a {
-            ty::ty_trait(~ty::TyTrait { def_id, ref substs, bounds, .. }) => {
+            ty::ty_trait(box ty::TyTrait {
+                    def_id,
+                    ref substs,
+                    bounds,
+                    ..
+                }) => {
                 ty::mk_trait(tcx, def_id, substs.clone(),
                              ty::RegionTraitStore(r_a, b_mutbl), bounds)
             }
diff --git a/src/librustc/middle/typeck/infer/mod.rs b/src/librustc/middle/typeck/infer/mod.rs
index 258f286d8f0..20bd47b3022 100644
--- a/src/librustc/middle/typeck/infer/mod.rs
+++ b/src/librustc/middle/typeck/infer/mod.rs
@@ -683,7 +683,7 @@ impl<'a> InferCtxt<'a> {
                                   ty::EmptyBuiltinBounds());
         let dummy1 = self.resolve_type_vars_if_possible(dummy0);
         match ty::get(dummy1).sty {
-            ty::ty_trait(~ty::TyTrait { ref def_id, ref substs, .. }) => {
+            ty::ty_trait(box ty::TyTrait { ref def_id, ref substs, .. }) => {
                 ty::TraitRef {
                     def_id: *def_id,
                     substs: (*substs).clone(),
diff --git a/src/librustc/middle/typeck/infer/region_inference/doc.rs b/src/librustc/middle/typeck/infer/region_inference/doc.rs
index a05d7a33fb4..1170244fbec 100644
--- a/src/librustc/middle/typeck/infer/region_inference/doc.rs
+++ b/src/librustc/middle/typeck/infer/region_inference/doc.rs
@@ -190,7 +190,7 @@ going on:
         *p += 1; *p
     }
     fn weird() {
-        let mut x: ~Foo = ~Foo { ... };
+        let mut x: Box<Foo> = box Foo { ... };
         'a: add(&mut (*x).f,
                 'b: inc(&mut (*x).f)) // (..)
     }
@@ -243,11 +243,11 @@ this similar but unsound example:
         *p += v;
     }
     ...
-    fn consume(x: ~Foo) -> uint {
+    fn consume(x: Box<Foo>) -> uint {
         x.f + x.g
     }
     fn weird() {
-        let mut x: ~Foo = ~Foo { ... };
+        let mut x: Box<Foo> = box Foo { ... };
         'a: add(&mut (*x).f, consume(x)) // (..)
     }
 
diff --git a/src/librustc/middle/typeck/variance.rs b/src/librustc/middle/typeck/variance.rs
index a4fae2d9aa4..df3af87b0f8 100644
--- a/src/librustc/middle/typeck/variance.rs
+++ b/src/librustc/middle/typeck/variance.rs
@@ -741,7 +741,7 @@ impl<'a> ConstraintContext<'a> {
                                                  substs, variance);
             }
 
-            ty::ty_trait(~ty::TyTrait { def_id, ref substs, .. }) => {
+            ty::ty_trait(box ty::TyTrait { def_id, ref substs, .. }) => {
                 let trait_def = ty::lookup_trait_def(self.tcx(), def_id);
                 self.add_constraints_from_substs(def_id, &trait_def.generics,
                                                  substs, variance);
@@ -768,11 +768,15 @@ impl<'a> ConstraintContext<'a> {
             }
 
             ty::ty_bare_fn(ty::BareFnTy { ref sig, .. }) |
-            ty::ty_closure(~ty::ClosureTy { ref sig, store: ty::UniqTraitStore, .. }) => {
+            ty::ty_closure(box ty::ClosureTy {
+                    ref sig,
+                    store: ty::UniqTraitStore,
+                    ..
+                }) => {
                 self.add_constraints_from_sig(sig, variance);
             }
 
-            ty::ty_closure(~ty::ClosureTy { ref sig,
+            ty::ty_closure(box ty::ClosureTy { ref sig,
                     store: ty::RegionTraitStore(region, _), .. }) => {
                 let contra = self.contravariant(variance);
                 self.add_constraints_from_region(region, contra);
diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs
index 06adce194f1..cf6466faba6 100644
--- a/src/librustc/util/ppaux.rs
+++ b/src/librustc/util/ppaux.rs
@@ -203,7 +203,7 @@ pub fn mt_to_str(cx: &ctxt, m: &mt) -> ~str {
 
 pub fn trait_store_to_str(cx: &ctxt, s: ty::TraitStore) -> ~str {
     match s {
-        ty::UniqTraitStore => "~".to_owned(),
+        ty::UniqTraitStore => "Box ".to_owned(),
         ty::RegionTraitStore(r, m) => {
             format!("{}{}", region_ptr_to_str(cx, r), mutability_to_str(m))
         }
@@ -385,7 +385,7 @@ pub fn ty_to_str(cx: &ctxt, typ: t) -> ~str {
                       did,
                       false)
       }
-      ty_trait(~ty::TyTrait {
+      ty_trait(box ty::TyTrait {
           def_id: did, ref substs, store, ref bounds
       }) => {
         let base = ty::item_path_str(cx, did);
@@ -500,7 +500,7 @@ impl<T:Repr> Repr for @T {
     }
 }
 
-impl<T:Repr> Repr for ~T {
+impl<T:Repr> Repr for Box<T> {
     fn repr(&self, tcx: &ctxt) -> ~str {
         (&**self).repr(tcx)
     }
diff --git a/src/librustdoc/clean.rs b/src/librustdoc/clean.rs
index 13a6ddd6e08..79fc0fbeada 100644
--- a/src/librustdoc/clean.rs
+++ b/src/librustdoc/clean.rs
@@ -690,26 +690,26 @@ pub enum Type {
     Self(ast::NodeId),
     /// Primitives are just the fixed-size numeric types (plus int/uint/float), and char.
     Primitive(ast::PrimTy),
-    Closure(~ClosureDecl, Option<Lifetime>),
-    Proc(~ClosureDecl),
+    Closure(Box<ClosureDecl>, Option<Lifetime>),
+    Proc(Box<ClosureDecl>),
     /// extern "ABI" fn
-    BareFunction(~BareFunctionDecl),
+    BareFunction(Box<BareFunctionDecl>),
     Tuple(Vec<Type>),
-    Vector(~Type),
-    FixedVector(~Type, ~str),
+    Vector(Box<Type>),
+    FixedVector(Box<Type>, ~str),
     String,
     Bool,
     /// aka TyNil
     Unit,
     /// aka TyBot
     Bottom,
-    Unique(~Type),
-    Managed(~Type),
-    RawPointer(Mutability, ~Type),
+    Unique(Box<Type>),
+    Managed(Box<Type>),
+    RawPointer(Mutability, Box<Type>),
     BorrowedRef {
         pub lifetime: Option<Lifetime>,
         pub mutability: Mutability,
-        pub type_: ~Type,
+        pub type_: Box<Type>,
     },
     // region, raw, other boxes, mutable
 }
diff --git a/src/librustdoc/html/highlight.rs b/src/librustdoc/html/highlight.rs
index 18b6298a3a0..f452be32778 100644
--- a/src/librustdoc/html/highlight.rs
+++ b/src/librustdoc/html/highlight.rs
@@ -83,8 +83,8 @@ fn doit(sess: &parse::ParseSess, mut lexer: lexer::StringReader, class: Option<&
         let klass = match next.tok {
             // If this '&' token is directly adjacent to another token, assume
             // that it's the address-of operator instead of the and-operator.
-            // This allows us to give all pointers their own class (~ and @ are
-            // below).
+            // This allows us to give all pointers their own class (`Box` and
+            // `@` are below).
             t::BINOP(t::AND) if lexer.peek().sp.lo == next.sp.hi => "kw-2",
             t::AT | t::TILDE => "kw-2",
 
diff --git a/src/librustdoc/test.rs b/src/librustdoc/test.rs
index d81ad62811f..0b8434d7d17 100644
--- a/src/librustdoc/test.rs
+++ b/src/librustdoc/test.rs
@@ -36,8 +36,11 @@ use html::markdown;
 use passes;
 use visit_ast::RustdocVisitor;
 
-pub fn run(input: &str, cfgs: Vec<~str>,
-           libs: HashSet<Path>, mut test_args: Vec<~str>) -> int {
+pub fn run(input: &str,
+           cfgs: Vec<~str>,
+           libs: HashSet<Path>,
+           mut test_args: Vec<~str>)
+           -> int {
     let input_path = Path::new(input);
     let input = driver::FileInput(input_path.clone());
 
@@ -128,7 +131,7 @@ fn runtest(test: &str, cratename: &str, libs: HashSet<Path>, should_fail: bool,
     let old = io::stdio::set_stderr(box w1);
     spawn(proc() {
         let mut p = io::ChanReader::new(rx);
-        let mut err = old.unwrap_or(box io::stderr() as ~Writer:Send);
+        let mut err = old.unwrap_or(box io::stderr() as Box<Writer:Send>);
         io::util::copy(&mut p, &mut err).unwrap();
     });
     let emitter = diagnostic::EmitterWriter::new(box w2);
diff --git a/src/librustuv/access.rs b/src/librustuv/access.rs
index 3ea58a71cfe..fbacf1ca314 100644
--- a/src/librustuv/access.rs
+++ b/src/librustuv/access.rs
@@ -15,9 +15,9 @@
 /// (the uv event loop).
 
 use std::cast;
-use std::sync::arc::UnsafeArc;
-use std::rt::task::{BlockedTask, Task};
 use std::rt::local::Local;
+use std::rt::task::{BlockedTask, Task};
+use std::sync::arc::UnsafeArc;
 
 use homing::HomingMissile;
 
@@ -52,7 +52,7 @@ impl Access {
         let inner: &mut Inner = unsafe { cast::transmute(self.inner.get()) };
 
         if inner.held {
-            let t: ~Task = Local::take();
+            let t: Box<Task> = Local::take();
             t.deschedule(1, |task| {
                 inner.queue.push(task);
                 Ok(())
diff --git a/src/librustuv/async.rs b/src/librustuv/async.rs
index 7b19be09bde..155dee3cfa8 100644
--- a/src/librustuv/async.rs
+++ b/src/librustuv/async.rs
@@ -26,12 +26,12 @@ pub struct AsyncWatcher {
 }
 
 struct Payload {
-    callback: ~Callback:Send,
+    callback: Box<Callback:Send>,
     exit_flag: Exclusive<bool>,
 }
 
 impl AsyncWatcher {
-    pub fn new(loop_: &mut Loop, cb: ~Callback:Send) -> AsyncWatcher {
+    pub fn new(loop_: &mut Loop, cb: Box<Callback:Send>) -> AsyncWatcher {
         let handle = UvHandle::alloc(None::<AsyncWatcher>, uvll::UV_ASYNC);
         assert_eq!(unsafe {
             uvll::uv_async_init(loop_.handle, handle, async_cb)
@@ -93,7 +93,7 @@ extern fn async_cb(handle: *uvll::uv_async_t) {
 
 extern fn close_cb(handle: *uvll::uv_handle_t) {
     // drop the payload
-    let _payload: ~Payload = unsafe {
+    let _payload: Box<Payload> = unsafe {
         cast::transmute(uvll::get_data_for_uv_handle(handle))
     };
     // and then free the handle
diff --git a/src/librustuv/homing.rs b/src/librustuv/homing.rs
index 89b68917c94..50825bab493 100644
--- a/src/librustuv/homing.rs
+++ b/src/librustuv/homing.rs
@@ -100,7 +100,7 @@ pub trait HomingIO {
         // to go (remember we have no preemption, so we're guaranteed to stay on
         // this event loop as long as we avoid the scheduler).
         if cur_loop_id != destination {
-            let cur_task: ~Task = Local::take();
+            let cur_task: Box<Task> = Local::take();
             cur_task.deschedule(1, |task| {
                 self.home().send(task);
                 Ok(())
diff --git a/src/librustuv/idle.rs b/src/librustuv/idle.rs
index 9fb525bc260..ba72e5db273 100644
--- a/src/librustuv/idle.rs
+++ b/src/librustuv/idle.rs
@@ -19,11 +19,11 @@ pub struct IdleWatcher {
     handle: *uvll::uv_idle_t,
     idle_flag: bool,
     closed: bool,
-    callback: ~Callback:Send,
+    callback: Box<Callback:Send>,
 }
 
 impl IdleWatcher {
-    pub fn new(loop_: &mut Loop, cb: ~Callback:Send) -> ~IdleWatcher {
+    pub fn new(loop_: &mut Loop, cb: Box<Callback:Send>) -> Box<IdleWatcher> {
         let handle = UvHandle::alloc(None::<IdleWatcher>, uvll::UV_IDLE);
         assert_eq!(unsafe {
             uvll::uv_idle_init(loop_.handle, handle)
@@ -49,7 +49,7 @@ impl IdleWatcher {
         extern fn onetime_cb(handle: *uvll::uv_idle_t) {
             unsafe {
                 let data = uvll::get_data_for_uv_handle(handle);
-                let f: ~proc() = cast::transmute(data);
+                let f: Box<proc()> = cast::transmute(data);
                 (*f)();
                 assert_eq!(uvll::uv_idle_stop(handle), 0);
                 uvll::uv_close(handle, close_cb);
@@ -126,16 +126,16 @@ mod test {
         }
     }
 
-    fn mk(v: uint) -> (~IdleWatcher, Chan) {
+    fn mk(v: uint) -> (Box<IdleWatcher>, Chan) {
         let rc = Rc::new(RefCell::new((None, 0)));
         let cb = box MyCallback(rc.clone(), v);
-        let cb = cb as ~Callback:;
+        let cb = cb as Box<Callback:>;
         let cb = unsafe { cast::transmute(cb) };
         (IdleWatcher::new(&mut local_loop().loop_, cb), rc)
     }
 
     fn sleep(chan: &Chan) -> uint {
-        let task: ~Task = Local::take();
+        let task: Box<Task> = Local::take();
         task.deschedule(1, |task| {
             match *chan.borrow_mut().deref_mut() {
                 (ref mut slot, _) => {
diff --git a/src/librustuv/lib.rs b/src/librustuv/lib.rs
index f7631f8e41d..84d4b6b4702 100644
--- a/src/librustuv/lib.rs
+++ b/src/librustuv/lib.rs
@@ -47,11 +47,11 @@ via `close` and `delete` methods.
 #[cfg(test)] extern crate realrustuv = "rustuv";
 extern crate libc;
 
+use libc::{c_int, c_void};
 use std::cast;
 use std::fmt;
 use std::io::IoError;
 use std::io;
-use libc::{c_int, c_void};
 use std::ptr::null;
 use std::ptr;
 use std::rt::local::Local;
@@ -124,8 +124,8 @@ pub mod stream;
 ///     // this code is running inside of a green task powered by libuv
 /// }
 /// ```
-pub fn event_loop() -> ~rtio::EventLoop:Send {
-    box uvio::UvEventLoop::new() as ~rtio::EventLoop:Send
+pub fn event_loop() -> Box<rtio::EventLoop:Send> {
+    box uvio::UvEventLoop::new() as Box<rtio::EventLoop:Send>
 }
 
 /// A type that wraps a uv handle
@@ -149,9 +149,9 @@ pub trait UvHandle<T> {
         cast::transmute(uvll::get_data_for_uv_handle(*h))
     }
 
-    fn install(~self) -> ~Self {
+    fn install(~self) -> Box<Self> {
         unsafe {
-            let myptr = cast::transmute::<&~Self, &*u8>(&self);
+            let myptr = cast::transmute::<&Box<Self>, &*u8>(&self);
             uvll::set_data_for_uv_handle(self.uv_handle(), *myptr);
         }
         self
@@ -242,7 +242,7 @@ fn wait_until_woken_after(slot: *mut Option<BlockedTask>,
     let _f = ForbidUnwind::new("wait_until_woken_after");
     unsafe {
         assert!((*slot).is_none());
-        let task: ~Task = Local::take();
+        let task: Box<Task> = Local::take();
         loop_.modify_blockers(1);
         task.deschedule(1, |task| {
             *slot = Some(task);
diff --git a/src/librustuv/net.rs b/src/librustuv/net.rs
index e12276e8f5b..a2701a57ca9 100644
--- a/src/librustuv/net.rs
+++ b/src/librustuv/net.rs
@@ -8,11 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use libc::{size_t, ssize_t, c_int, c_void, c_uint};
+use libc;
 use std::cast;
 use std::io::{IoError, IoResult};
 use std::io::net::ip;
-use libc::{size_t, ssize_t, c_int, c_void, c_uint};
-use libc;
 use std::mem;
 use std::ptr;
 use std::rt::rtio;
@@ -152,7 +152,7 @@ fn socket_name(sk: SocketNameKind,
 pub struct ConnectCtx {
     pub status: c_int,
     pub task: Option<BlockedTask>,
-    pub timer: Option<~TimerWatcher>,
+    pub timer: Option<Box<TimerWatcher>>,
 }
 
 pub struct AcceptTimeout {
@@ -352,12 +352,12 @@ pub struct TcpListener {
     home: HomeHandle,
     handle: *uvll::uv_pipe_t,
     closing_task: Option<BlockedTask>,
-    outgoing: Sender<Result<~rtio::RtioTcpStream:Send, IoError>>,
-    incoming: Receiver<Result<~rtio::RtioTcpStream:Send, IoError>>,
+    outgoing: Sender<Result<Box<rtio::RtioTcpStream:Send>, IoError>>,
+    incoming: Receiver<Result<Box<rtio::RtioTcpStream:Send>, IoError>>,
 }
 
 pub struct TcpAcceptor {
-    listener: ~TcpListener,
+    listener: Box<TcpListener>,
     timeout: AcceptTimeout,
 }
 
@@ -455,7 +455,7 @@ impl rtio::RtioTcpStream for TcpWatcher {
         })
     }
 
-    fn clone(&self) -> ~rtio::RtioTcpStream:Send {
+    fn clone(&self) -> Box<rtio::RtioTcpStream:Send> {
         box TcpWatcher {
             handle: self.handle,
             stream: StreamWatcher::new(self.handle),
@@ -463,7 +463,7 @@ impl rtio::RtioTcpStream for TcpWatcher {
             refcount: self.refcount.clone(),
             write_access: self.write_access.clone(),
             read_access: self.read_access.clone(),
-        } as ~rtio::RtioTcpStream:Send
+        } as Box<rtio::RtioTcpStream:Send>
     }
 
     fn close_write(&mut self) -> Result<(), IoError> {
@@ -516,7 +516,7 @@ impl Drop for TcpWatcher {
 
 impl TcpListener {
     pub fn bind(io: &mut UvIoFactory, address: ip::SocketAddr)
-                -> Result<~TcpListener, UvError> {
+                -> Result<Box<TcpListener>, UvError> {
         let handle = unsafe { uvll::malloc_handle(uvll::UV_TCP) };
         assert_eq!(unsafe {
             uvll::uv_tcp_init(io.uv_loop(), handle)
@@ -557,7 +557,7 @@ impl rtio::RtioSocket for TcpListener {
 }
 
 impl rtio::RtioTcpListener for TcpListener {
-    fn listen(~self) -> Result<~rtio::RtioTcpAcceptor:Send, IoError> {
+    fn listen(~self) -> Result<Box<rtio::RtioTcpAcceptor:Send>, IoError> {
         // create the acceptor object from ourselves
         let mut acceptor = box TcpAcceptor {
             listener: self,
@@ -567,7 +567,7 @@ impl rtio::RtioTcpListener for TcpListener {
         let _m = acceptor.fire_homing_missile();
         // FIXME: the 128 backlog should be configurable
         match unsafe { uvll::uv_listen(acceptor.listener.handle, 128, listen_cb) } {
-            0 => Ok(acceptor as ~rtio::RtioTcpAcceptor:Send),
+            0 => Ok(acceptor as Box<rtio::RtioTcpAcceptor:Send>),
             n => Err(uv_error_to_io_error(UvError(n))),
         }
     }
@@ -583,7 +583,7 @@ extern fn listen_cb(server: *uvll::uv_stream_t, status: c_int) {
             });
             let client = TcpWatcher::new_home(&loop_, tcp.home().clone());
             assert_eq!(unsafe { uvll::uv_accept(server, client.handle) }, 0);
-            Ok(box client as ~rtio::RtioTcpStream:Send)
+            Ok(box client as Box<rtio::RtioTcpStream:Send>)
         }
         n => Err(uv_error_to_io_error(UvError(n)))
     };
@@ -611,7 +611,7 @@ impl rtio::RtioSocket for TcpAcceptor {
 }
 
 impl rtio::RtioTcpAcceptor for TcpAcceptor {
-    fn accept(&mut self) -> Result<~rtio::RtioTcpStream:Send, IoError> {
+    fn accept(&mut self) -> Result<Box<rtio::RtioTcpStream:Send>, IoError> {
         self.timeout.accept(&self.listener.incoming)
     }
 
@@ -879,14 +879,14 @@ impl rtio::RtioUdpSocket for UdpWatcher {
         })
     }
 
-    fn clone(&self) -> ~rtio::RtioUdpSocket:Send {
+    fn clone(&self) -> Box<rtio::RtioUdpSocket:Send> {
         box UdpWatcher {
             handle: self.handle,
             home: self.home.clone(),
             refcount: self.refcount.clone(),
             write_access: self.write_access.clone(),
             read_access: self.read_access.clone(),
-        } as ~rtio::RtioUdpSocket:Send
+        } as Box<rtio::RtioUdpSocket:Send>
     }
 }
 
diff --git a/src/librustuv/pipe.rs b/src/librustuv/pipe.rs
index 99551e8f35b..0edc13afcf5 100644
--- a/src/librustuv/pipe.rs
+++ b/src/librustuv/pipe.rs
@@ -8,9 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use libc;
 use std::c_str::CString;
 use std::io::IoError;
-use libc;
 use std::rt::rtio::{RtioPipe, RtioUnixListener, RtioUnixAcceptor};
 
 use access::Access;
@@ -36,12 +36,12 @@ pub struct PipeWatcher {
 pub struct PipeListener {
     home: HomeHandle,
     pipe: *uvll::uv_pipe_t,
-    outgoing: Sender<Result<~RtioPipe:Send, IoError>>,
-    incoming: Receiver<Result<~RtioPipe:Send, IoError>>,
+    outgoing: Sender<Result<Box<RtioPipe:Send>, IoError>>,
+    incoming: Receiver<Result<Box<RtioPipe:Send>, IoError>>,
 }
 
 pub struct PipeAcceptor {
-    listener: ~PipeListener,
+    listener: Box<PipeListener>,
     timeout: net::AcceptTimeout,
 }
 
@@ -121,7 +121,7 @@ impl RtioPipe for PipeWatcher {
         self.stream.write(buf).map_err(uv_error_to_io_error)
     }
 
-    fn clone(&self) -> ~RtioPipe:Send {
+    fn clone(&self) -> Box<RtioPipe:Send> {
         box PipeWatcher {
             stream: StreamWatcher::new(self.stream.handle),
             defused: false,
@@ -129,7 +129,7 @@ impl RtioPipe for PipeWatcher {
             refcount: self.refcount.clone(),
             read_access: self.read_access.clone(),
             write_access: self.write_access.clone(),
-        } as ~RtioPipe:Send
+        } as Box<RtioPipe:Send>
     }
 }
 
@@ -154,7 +154,7 @@ impl Drop for PipeWatcher {
 
 impl PipeListener {
     pub fn bind(io: &mut UvIoFactory, name: &CString)
-        -> Result<~PipeListener, UvError>
+        -> Result<Box<PipeListener>, UvError>
     {
         let pipe = PipeWatcher::new(io, false);
         match unsafe {
@@ -179,7 +179,7 @@ impl PipeListener {
 }
 
 impl RtioUnixListener for PipeListener {
-    fn listen(~self) -> Result<~RtioUnixAcceptor:Send, IoError> {
+    fn listen(~self) -> Result<Box<RtioUnixAcceptor:Send>, IoError> {
         // create the acceptor object from ourselves
         let mut acceptor = box PipeAcceptor {
             listener: self,
@@ -189,7 +189,7 @@ impl RtioUnixListener for PipeListener {
         let _m = acceptor.fire_homing_missile();
         // FIXME: the 128 backlog should be configurable
         match unsafe { uvll::uv_listen(acceptor.listener.pipe, 128, listen_cb) } {
-            0 => Ok(acceptor as ~RtioUnixAcceptor:Send),
+            0 => Ok(acceptor as Box<RtioUnixAcceptor:Send>),
             n => Err(uv_error_to_io_error(UvError(n))),
         }
     }
@@ -214,7 +214,7 @@ extern fn listen_cb(server: *uvll::uv_stream_t, status: libc::c_int) {
             });
             let client = PipeWatcher::new_home(&loop_, pipe.home().clone(), false);
             assert_eq!(unsafe { uvll::uv_accept(server, client.handle()) }, 0);
-            Ok(box client as ~RtioPipe:Send)
+            Ok(box client as Box<RtioPipe:Send>)
         }
         n => Err(uv_error_to_io_error(UvError(n)))
     };
@@ -231,7 +231,7 @@ impl Drop for PipeListener {
 // PipeAcceptor implementation and traits
 
 impl RtioUnixAcceptor for PipeAcceptor {
-    fn accept(&mut self) -> Result<~RtioPipe:Send, IoError> {
+    fn accept(&mut self) -> Result<Box<RtioPipe:Send>, IoError> {
         self.timeout.accept(&self.listener.incoming)
     }
 
diff --git a/src/librustuv/process.rs b/src/librustuv/process.rs
index d6d1f754b23..d744607050f 100644
--- a/src/librustuv/process.rs
+++ b/src/librustuv/process.rs
@@ -8,10 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::io::IoError;
-use std::io::process;
 use libc::c_int;
 use libc;
+use std::io::IoError;
+use std::io::process;
 use std::ptr;
 use std::rt::rtio::RtioProcess;
 use std::rt::task::BlockedTask;
@@ -40,8 +40,7 @@ impl Process {
     /// Returns either the corresponding process object or an error which
     /// occurred.
     pub fn spawn(io_loop: &mut UvIoFactory, config: process::ProcessConfig)
-                -> Result<(~Process, ~[Option<PipeWatcher>]), UvError>
-    {
+                -> Result<(Box<Process>, ~[Option<PipeWatcher>]), UvError> {
         let cwd = config.cwd.map(|s| s.to_c_str());
         let mut io = vec![config.stdin, config.stdout, config.stderr];
         for slot in config.extra_io.iter() {
diff --git a/src/librustuv/queue.rs b/src/librustuv/queue.rs
index 58761045b97..561c1f6f95f 100644
--- a/src/librustuv/queue.rs
+++ b/src/librustuv/queue.rs
@@ -20,8 +20,8 @@
 
 #![allow(dead_code)]
 
-use std::cast;
 use libc::c_void;
+use std::cast;
 use std::rt::task::BlockedTask;
 use std::unstable::mutex::NativeMutex;
 use std::sync::arc::UnsafeArc;
@@ -107,7 +107,7 @@ extern fn async_cb(handle: *uvll::uv_async_t) {
 }
 
 impl QueuePool {
-    pub fn new(loop_: &mut Loop) -> ~QueuePool {
+    pub fn new(loop_: &mut Loop) -> Box<QueuePool> {
         let handle = UvHandle::alloc(None::<AsyncWatcher>, uvll::UV_ASYNC);
         let state = UnsafeArc::new(State {
             handle: handle,
diff --git a/src/librustuv/signal.rs b/src/librustuv/signal.rs
index 3f56d3ad686..b2e1c752012 100644
--- a/src/librustuv/signal.rs
+++ b/src/librustuv/signal.rs
@@ -26,8 +26,8 @@ pub struct SignalWatcher {
 }
 
 impl SignalWatcher {
-    pub fn new(io: &mut UvIoFactory, signum: Signum,
-               channel: Sender<Signum>) -> Result<~SignalWatcher, UvError> {
+    pub fn new(io: &mut UvIoFactory, signum: Signum, channel: Sender<Signum>)
+               -> Result<Box<SignalWatcher>, UvError> {
         let s = box SignalWatcher {
             handle: UvHandle::alloc(None::<SignalWatcher>, uvll::UV_SIGNAL),
             home: io.make_handle(),
diff --git a/src/librustuv/timer.rs b/src/librustuv/timer.rs
index 66c1a903910..216eb600130 100644
--- a/src/librustuv/timer.rs
+++ b/src/librustuv/timer.rs
@@ -32,7 +32,7 @@ pub enum NextAction {
 }
 
 impl TimerWatcher {
-    pub fn new(io: &mut UvIoFactory) -> ~TimerWatcher {
+    pub fn new(io: &mut UvIoFactory) -> Box<TimerWatcher> {
         let handle = io.make_handle();
         let me = box TimerWatcher::new_home(&io.loop_, handle);
         me.install()
diff --git a/src/librustuv/uvio.rs b/src/librustuv/uvio.rs
index 999c5ec4e33..17a64fdb517 100644
--- a/src/librustuv/uvio.rs
+++ b/src/librustuv/uvio.rs
@@ -93,17 +93,16 @@ impl EventLoop for UvEventLoop {
         IdleWatcher::onetime(&mut self.uvio.loop_, f);
     }
 
-    fn pausable_idle_callback(&mut self, cb: ~rtio::Callback:Send)
-        -> ~rtio::PausableIdleCallback:Send
-    {
-        IdleWatcher::new(&mut self.uvio.loop_,
-                         cb) as ~rtio::PausableIdleCallback:Send
+    fn pausable_idle_callback(&mut self, cb: Box<rtio::Callback:Send>)
+                              -> Box<rtio::PausableIdleCallback:Send> {
+        IdleWatcher::new(&mut self.uvio.loop_, cb)
+                         as Box<rtio::PausableIdleCallback:Send>
     }
 
-    fn remote_callback(&mut self, f: ~rtio::Callback:Send)
-        -> ~rtio::RemoteCallback:Send
-    {
-        box AsyncWatcher::new(&mut self.uvio.loop_, f) as ~rtio::RemoteCallback:Send
+    fn remote_callback(&mut self, f: Box<rtio::Callback:Send>)
+                       -> Box<rtio::RemoteCallback:Send> {
+        box AsyncWatcher::new(&mut self.uvio.loop_, f) as
+            Box<rtio::RemoteCallback:Send>
     }
 
     fn io<'a>(&'a mut self) -> Option<&'a mut rtio::IoFactory> {
@@ -132,7 +131,7 @@ fn test_callback_run_once() {
 
 pub struct UvIoFactory {
     pub loop_: Loop,
-    handle_pool: Option<~QueuePool>,
+    handle_pool: Option<Box<QueuePool>>,
 }
 
 impl UvIoFactory {
@@ -151,30 +150,31 @@ impl IoFactory for UvIoFactory {
     // NB: This blocks the task waiting on the connection.
     // It would probably be better to return a future
     fn tcp_connect(&mut self, addr: SocketAddr, timeout: Option<u64>)
-        -> Result<~rtio::RtioTcpStream:Send, IoError>
-    {
+                   -> Result<Box<rtio::RtioTcpStream:Send>, IoError> {
         match TcpWatcher::connect(self, addr, timeout) {
-            Ok(t) => Ok(box t as ~rtio::RtioTcpStream:Send),
+            Ok(t) => Ok(box t as Box<rtio::RtioTcpStream:Send>),
             Err(e) => Err(uv_error_to_io_error(e)),
         }
     }
 
-    fn tcp_bind(&mut self, addr: SocketAddr) -> Result<~rtio::RtioTcpListener:Send, IoError> {
+    fn tcp_bind(&mut self, addr: SocketAddr)
+                -> Result<Box<rtio::RtioTcpListener:Send>, IoError> {
         match TcpListener::bind(self, addr) {
-            Ok(t) => Ok(t as ~rtio::RtioTcpListener:Send),
+            Ok(t) => Ok(t as Box<rtio::RtioTcpListener:Send>),
             Err(e) => Err(uv_error_to_io_error(e)),
         }
     }
 
-    fn udp_bind(&mut self, addr: SocketAddr) -> Result<~rtio::RtioUdpSocket:Send, IoError> {
+    fn udp_bind(&mut self, addr: SocketAddr)
+                -> Result<Box<rtio::RtioUdpSocket:Send>, IoError> {
         match UdpWatcher::bind(self, addr) {
-            Ok(u) => Ok(box u as ~rtio::RtioUdpSocket:Send),
+            Ok(u) => Ok(box u as Box<rtio::RtioUdpSocket:Send>),
             Err(e) => Err(uv_error_to_io_error(e)),
         }
     }
 
-    fn timer_init(&mut self) -> Result<~rtio::RtioTimer:Send, IoError> {
-        Ok(TimerWatcher::new(self) as ~rtio::RtioTimer:Send)
+    fn timer_init(&mut self) -> Result<Box<rtio::RtioTimer:Send>, IoError> {
+        Ok(TimerWatcher::new(self) as Box<rtio::RtioTimer:Send>)
     }
 
     fn get_host_addresses(&mut self, host: Option<&str>, servname: Option<&str>,
@@ -183,13 +183,14 @@ impl IoFactory for UvIoFactory {
         r.map_err(uv_error_to_io_error)
     }
 
-    fn fs_from_raw_fd(&mut self, fd: c_int,
-                      close: rtio::CloseBehavior) -> ~rtio::RtioFileStream:Send {
-        box FileWatcher::new(self, fd, close) as ~rtio::RtioFileStream:Send
+    fn fs_from_raw_fd(&mut self, fd: c_int, close: rtio::CloseBehavior)
+                      -> Box<rtio::RtioFileStream:Send> {
+        box FileWatcher::new(self, fd, close) as
+            Box<rtio::RtioFileStream:Send>
     }
 
     fn fs_open(&mut self, path: &CString, fm: FileMode, fa: FileAccess)
-        -> Result<~rtio::RtioFileStream:Send, IoError> {
+               -> Result<Box<rtio::RtioFileStream:Send>, IoError> {
         let flags = match fm {
             io::Open => 0,
             io::Append => libc::O_APPEND,
@@ -205,7 +206,7 @@ impl IoFactory for UvIoFactory {
         };
 
         match FsRequest::open(self, path, flags as int, mode as int) {
-            Ok(fs) => Ok(box fs as ~rtio::RtioFileStream:Send),
+            Ok(fs) => Ok(box fs as Box<rtio::RtioFileStream:Send>),
             Err(e) => Err(uv_error_to_io_error(e))
         }
     }
@@ -270,12 +271,16 @@ impl IoFactory for UvIoFactory {
     }
 
     fn spawn(&mut self, config: ProcessConfig)
-            -> Result<(~rtio::RtioProcess:Send, ~[Option<~rtio::RtioPipe:Send>]), IoError>
+            -> Result<(Box<rtio::RtioProcess:Send>,
+                       ~[Option<Box<rtio::RtioPipe:Send>>]),
+                      IoError>
     {
         match Process::spawn(self, config) {
             Ok((p, io)) => {
-                Ok((p as ~rtio::RtioProcess:Send,
-                    io.move_iter().map(|i| i.map(|p| box p as ~rtio::RtioPipe:Send)).collect()))
+                Ok((p as Box<rtio::RtioProcess:Send>,
+                    io.move_iter().map(|i| i.map(|p| {
+                        box p as Box<rtio::RtioPipe:Send>
+                    })).collect()))
             }
             Err(e) => Err(uv_error_to_io_error(e)),
         }
@@ -285,41 +290,42 @@ impl IoFactory for UvIoFactory {
         Process::kill(pid, signum).map_err(uv_error_to_io_error)
     }
 
-    fn unix_bind(&mut self, path: &CString) -> Result<~rtio::RtioUnixListener:Send, IoError>
-    {
+    fn unix_bind(&mut self, path: &CString)
+                 -> Result<Box<rtio::RtioUnixListener:Send>, IoError> {
         match PipeListener::bind(self, path) {
-            Ok(p) => Ok(p as ~rtio::RtioUnixListener:Send),
+            Ok(p) => Ok(p as Box<rtio::RtioUnixListener:Send>),
             Err(e) => Err(uv_error_to_io_error(e)),
         }
     }
 
-    fn unix_connect(&mut self, path: &CString,
-                    timeout: Option<u64>) -> Result<~rtio::RtioPipe:Send, IoError> {
+    fn unix_connect(&mut self, path: &CString, timeout: Option<u64>)
+                    -> Result<Box<rtio::RtioPipe:Send>, IoError> {
         match PipeWatcher::connect(self, path, timeout) {
-            Ok(p) => Ok(box p as ~rtio::RtioPipe:Send),
+            Ok(p) => Ok(box p as Box<rtio::RtioPipe:Send>),
             Err(e) => Err(uv_error_to_io_error(e)),
         }
     }
 
     fn tty_open(&mut self, fd: c_int, readable: bool)
-            -> Result<~rtio::RtioTTY:Send, IoError> {
+            -> Result<Box<rtio::RtioTTY:Send>, IoError> {
         match TtyWatcher::new(self, fd, readable) {
-            Ok(tty) => Ok(box tty as ~rtio::RtioTTY:Send),
+            Ok(tty) => Ok(box tty as Box<rtio::RtioTTY:Send>),
             Err(e) => Err(uv_error_to_io_error(e))
         }
     }
 
-    fn pipe_open(&mut self, fd: c_int) -> Result<~rtio::RtioPipe:Send, IoError> {
+    fn pipe_open(&mut self, fd: c_int)
+                 -> Result<Box<rtio::RtioPipe:Send>, IoError> {
         match PipeWatcher::open(self, fd) {
-            Ok(s) => Ok(box s as ~rtio::RtioPipe:Send),
+            Ok(s) => Ok(box s as Box<rtio::RtioPipe:Send>),
             Err(e) => Err(uv_error_to_io_error(e))
         }
     }
 
     fn signal(&mut self, signum: Signum, channel: Sender<Signum>)
-        -> Result<~rtio::RtioSignal:Send, IoError> {
+        -> Result<Box<rtio::RtioSignal:Send>, IoError> {
         match SignalWatcher::new(self, signum, channel) {
-            Ok(s) => Ok(s as ~rtio::RtioSignal:Send),
+            Ok(s) => Ok(s as Box<rtio::RtioSignal:Send>),
             Err(e) => Err(uv_error_to_io_error(e)),
         }
     }
diff --git a/src/libserialize/json.rs b/src/libserialize/json.rs
index 5c86566b2af..d1fe04bccf8 100644
--- a/src/libserialize/json.rs
+++ b/src/libserialize/json.rs
@@ -113,7 +113,7 @@ pub struct MyStruct  {
 
 impl ToJson for MyStruct {
     fn to_json( &self ) -> json::Json {
-        let mut d = ~TreeMap::new();
+        let mut d = box TreeMap::new();
         d.insert("attr1".to_owned(), self.attr1.to_json());
         d.insert("attr2".to_owned(), self.attr2.to_json());
         json::Object(d)
@@ -206,7 +206,7 @@ pub struct TestStruct1  {
 
 impl ToJson for TestStruct1 {
     fn to_json( &self ) -> json::Json {
-        let mut d = ~TreeMap::new();
+        let mut d = box TreeMap::new();
         d.insert("data_int".to_owned(), self.data_int.to_json());
         d.insert("data_str".to_owned(), self.data_str.to_json());
         d.insert("data_vector".to_owned(), self.data_vector.to_json());
@@ -232,21 +232,20 @@ fn main() {
 
 */
 
-use collections::HashMap;
 use std::char;
 use std::f64;
+use std::fmt;
 use std::io::MemWriter;
 use std::io;
-use std::num;
-use std::str;
-use std::str::ScalarValue;
-use std::strbuf::StrBuf;
-use std::fmt;
-use std::vec::Vec;
 use std::mem::swap;
+use std::num;
+use std::str::ScalarValue;
+use std::str;
+use std::strbuf::StrBuf;
+use std::vec::Vec;
 
 use Encodable;
-use collections::TreeMap;
+use collections::{HashMap, TreeMap};
 
 /// Represents a json value
 #[deriving(Clone, Eq)]
@@ -255,7 +254,7 @@ pub enum Json {
     String(~str),
     Boolean(bool),
     List(List),
-    Object(~Object),
+    Object(Box<Object>),
     Null,
 }
 
diff --git a/src/libserialize/serialize.rs b/src/libserialize/serialize.rs
index 65f1016515f..9d68705fca7 100644
--- a/src/libserialize/serialize.rs
+++ b/src/libserialize/serialize.rs
@@ -391,14 +391,14 @@ impl<'a, E, S:Encoder<E>,T:Encodable<S, E>> Encodable<S, E> for &'a T {
     }
 }
 
-impl<E, S:Encoder<E>,T:Encodable<S, E>> Encodable<S, E> for ~T {
+impl<E, S:Encoder<E>,T:Encodable<S, E>> Encodable<S, E> for Box<T> {
     fn encode(&self, s: &mut S) -> Result<(), E> {
         (**self).encode(s)
     }
 }
 
-impl<E, D:Decoder<E>,T:Decodable<D, E>> Decodable<D, E> for ~T {
-    fn decode(d: &mut D) -> Result<~T, E> {
+impl<E, D:Decoder<E>,T:Decodable<D, E>> Decodable<D, E> for Box<T> {
+    fn decode(d: &mut D) -> Result<Box<T>, E> {
         Ok(box try!(Decodable::decode(d)))
     }
 }
diff --git a/src/libstd/any.rs b/src/libstd/any.rs
index e448b7b8e24..2c1ce9fa779 100644
--- a/src/libstd/any.rs
+++ b/src/libstd/any.rs
@@ -17,12 +17,13 @@
 //! As `&Any` (a borrowed trait object), it has the `is` and `as_ref` methods, to test if the
 //! contained value is of a given type, and to get a reference to the inner value as a type. As
 //! `&mut Any`, there is also the `as_mut` method, for getting a mutable reference to the inner
-//! value. `~Any` adds the `move` method, which will unwrap a `~T` from the object.  See the
-//! extension traits (`*Ext`) for the full details.
+//! value. `Box<Any>` adds the `move` method, which will unwrap a `Box<T>` from the object.  See
+//! the extension traits (`*Ext`) for the full details.
 
 use cast::{transmute, transmute_copy};
 use fmt;
 use option::{Option, Some, None};
+use owned::Box;
 use raw::TraitObject;
 use result::{Result, Ok, Err};
 use intrinsics::TypeId;
@@ -121,12 +122,12 @@ impl<'a> AnyMutRefExt<'a> for &'a mut Any {
 pub trait AnyOwnExt {
     /// Returns the boxed value if it is of type `T`, or
     /// `Err(Self)` if it isn't.
-    fn move<T: 'static>(self) -> Result<~T, Self>;
+    fn move<T: 'static>(self) -> Result<Box<T>, Self>;
 }
 
-impl AnyOwnExt for ~Any {
+impl AnyOwnExt for Box<Any> {
     #[inline]
-    fn move<T: 'static>(self) -> Result<~T, ~Any> {
+    fn move<T: 'static>(self) -> Result<Box<T>, Box<Any>> {
         if self.is::<T>() {
             unsafe {
                 // Get the raw representation of the trait object
@@ -148,9 +149,9 @@ impl AnyOwnExt for ~Any {
 // Trait implementations
 ///////////////////////////////////////////////////////////////////////////////
 
-impl fmt::Show for ~Any {
+impl fmt::Show for Box<Any> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.pad("~Any")
+        f.pad("Box<Any>")
     }
 }
 
@@ -164,6 +165,7 @@ impl<'a> fmt::Show for &'a Any {
 mod tests {
     use prelude::*;
     use super::*;
+    use owned::Box;
     use str::StrSlice;
 
     #[deriving(Eq, Show)]
@@ -190,7 +192,7 @@ mod tests {
 
     #[test]
     fn any_owning() {
-        let (a, b, c) = (box 5u as ~Any, box TEST as ~Any, box Test as ~Any);
+        let (a, b, c) = (box 5u as Box<Any>, box TEST as Box<Any>, box Test as Box<Any>);
 
         assert!(a.is::<uint>());
         assert!(!b.is::<uint>());
@@ -268,8 +270,8 @@ mod tests {
 
     #[test]
     fn any_move() {
-        let a = box 8u as ~Any;
-        let b = box Test as ~Any;
+        let a = box 8u as Box<Any>;
+        let b = box Test as Box<Any>;
 
         match a.move::<uint>() {
             Ok(a) => { assert_eq!(a, box 8u); }
@@ -280,19 +282,19 @@ mod tests {
             Err(..) => fail!()
         }
 
-        let a = box 8u as ~Any;
-        let b = box Test as ~Any;
+        let a = box 8u as Box<Any>;
+        let b = box Test as Box<Any>;
 
-        assert!(a.move::<~Test>().is_err());
-        assert!(b.move::<~uint>().is_err());
+        assert!(a.move::<Box<Test>>().is_err());
+        assert!(b.move::<Box<uint>>().is_err());
     }
 
     #[test]
     fn test_show() {
-        let a = box 8u as ~Any;
-        let b = box Test as ~Any;
-        assert_eq!(format!("{}", a), "~Any".to_owned());
-        assert_eq!(format!("{}", b), "~Any".to_owned());
+        let a = box 8u as Box<Any>;
+        let b = box Test as Box<Any>;
+        assert_eq!(format!("{}", a), "Box<Any>".to_owned());
+        assert_eq!(format!("{}", b), "Box<Any>".to_owned());
 
         let a = &8u as &Any;
         let b = &Test as &Any;
diff --git a/src/libstd/clone.rs b/src/libstd/clone.rs
index e25f9c5ad4f..36d1cd9ba94 100644
--- a/src/libstd/clone.rs
+++ b/src/libstd/clone.rs
@@ -21,6 +21,8 @@ the `clone` method.
 
 */
 
+use owned::Box;
+
 /// A common trait for cloning an object.
 pub trait Clone {
     /// Returns a copy of the value. The contents of owned pointers
@@ -39,14 +41,14 @@ pub trait Clone {
     }
 }
 
-impl<T: Clone> Clone for ~T {
+impl<T: Clone> Clone for Box<T> {
     /// Return a copy of the owned box.
     #[inline]
-    fn clone(&self) -> ~T { box {(**self).clone()} }
+    fn clone(&self) -> Box<T> { box {(**self).clone()} }
 
     /// Perform copy-assignment from `source` by reusing the existing allocation.
     #[inline]
-    fn clone_from(&mut self, source: &~T) {
+    fn clone_from(&mut self, source: &Box<T>) {
         (**self).clone_from(&(**source));
     }
 }
@@ -127,7 +129,7 @@ extern_fn_clone!(A, B, C, D, E, F, G, H)
 #[test]
 fn test_owned_clone() {
     let a = box 5i;
-    let b: ~int = a.clone();
+    let b: Box<int> = a.clone();
     assert_eq!(a, b);
 }
 
diff --git a/src/libstd/comm/mod.rs b/src/libstd/comm/mod.rs
index c7849892465..bd1def518f0 100644
--- a/src/libstd/comm/mod.rs
+++ b/src/libstd/comm/mod.rs
@@ -279,6 +279,7 @@ use kinds::marker;
 use mem;
 use ops::Drop;
 use option::{Some, None, Option};
+use owned::Box;
 use result::{Ok, Err, Result};
 use rt::local::Local;
 use rt::task::{Task, BlockedTask};
@@ -297,6 +298,7 @@ macro_rules! test (
             use prelude::*;
             use super::*;
             use super::super::*;
+            use owned::Box;
             use task;
 
             fn f() $b
@@ -549,7 +551,7 @@ impl<T: Send> Sender<T> {
         let cnt = self.sends.get() + 1;
         self.sends.set(cnt);
         if cnt % (RESCHED_FREQ as uint) == 0 {
-            let task: Option<~Task> = Local::try_take();
+            let task: Option<Box<Task>> = Local::try_take();
             task.map(|t| t.maybe_yield());
         }
 
@@ -773,7 +775,7 @@ impl<T: Send> Receiver<T> {
         let cnt = self.receives.get() + 1;
         self.receives.set(cnt);
         if cnt % (RESCHED_FREQ as uint) == 0 {
-            let task: Option<~Task> = Local::try_take();
+            let task: Option<Box<Task>> = Local::try_take();
             task.map(|t| t.maybe_yield());
         }
 
@@ -979,6 +981,7 @@ mod test {
 
     use native;
     use os;
+    use owned::Box;
     use super::*;
 
     pub fn stress_factor() -> uint {
@@ -1197,7 +1200,7 @@ mod test {
 
     test!(fn oneshot_single_thread_send_port_close() {
         // Testing that the sender cleans up the payload if receiver is closed
-        let (tx, rx) = channel::<~int>();
+        let (tx, rx) = channel::<Box<int>>();
         drop(rx);
         tx.send(box 0);
     } #[should_fail])
@@ -1214,7 +1217,7 @@ mod test {
     })
 
     test!(fn oneshot_single_thread_send_then_recv() {
-        let (tx, rx) = channel::<~int>();
+        let (tx, rx) = channel::<Box<int>>();
         tx.send(box 10);
         assert!(rx.recv() == box 10);
     })
@@ -1263,7 +1266,7 @@ mod test {
     })
 
     test!(fn oneshot_multi_task_recv_then_send() {
-        let (tx, rx) = channel::<~int>();
+        let (tx, rx) = channel::<Box<int>>();
         spawn(proc() {
             assert!(rx.recv() == box 10);
         });
@@ -1272,7 +1275,7 @@ mod test {
     })
 
     test!(fn oneshot_multi_task_recv_then_close() {
-        let (tx, rx) = channel::<~int>();
+        let (tx, rx) = channel::<Box<int>>();
         spawn(proc() {
             drop(tx);
         });
@@ -1340,7 +1343,7 @@ mod test {
             send(tx, 0);
             recv(rx, 0);
 
-            fn send(tx: Sender<~int>, i: int) {
+            fn send(tx: Sender<Box<int>>, i: int) {
                 if i == 10 { return }
 
                 spawn(proc() {
@@ -1349,7 +1352,7 @@ mod test {
                 });
             }
 
-            fn recv(rx: Receiver<~int>, i: int) {
+            fn recv(rx: Receiver<Box<int>>, i: int) {
                 if i == 10 { return }
 
                 spawn(proc() {
@@ -1513,6 +1516,7 @@ mod test {
 mod sync_tests {
     use prelude::*;
     use os;
+    use owned::Box;
 
     pub fn stress_factor() -> uint {
         match os::getenv("RUST_TEST_STRESS") {
@@ -1657,7 +1661,7 @@ mod sync_tests {
 
     test!(fn oneshot_single_thread_send_port_close() {
         // Testing that the sender cleans up the payload if receiver is closed
-        let (tx, rx) = sync_channel::<~int>(0);
+        let (tx, rx) = sync_channel::<Box<int>>(0);
         drop(rx);
         tx.send(box 0);
     } #[should_fail])
@@ -1674,7 +1678,7 @@ mod sync_tests {
     })
 
     test!(fn oneshot_single_thread_send_then_recv() {
-        let (tx, rx) = sync_channel::<~int>(1);
+        let (tx, rx) = sync_channel::<Box<int>>(1);
         tx.send(box 10);
         assert!(rx.recv() == box 10);
     })
@@ -1728,7 +1732,7 @@ mod sync_tests {
     })
 
     test!(fn oneshot_multi_task_recv_then_send() {
-        let (tx, rx) = sync_channel::<~int>(0);
+        let (tx, rx) = sync_channel::<Box<int>>(0);
         spawn(proc() {
             assert!(rx.recv() == box 10);
         });
@@ -1737,7 +1741,7 @@ mod sync_tests {
     })
 
     test!(fn oneshot_multi_task_recv_then_close() {
-        let (tx, rx) = sync_channel::<~int>(0);
+        let (tx, rx) = sync_channel::<Box<int>>(0);
         spawn(proc() {
             drop(tx);
         });
@@ -1805,7 +1809,7 @@ mod sync_tests {
             send(tx, 0);
             recv(rx, 0);
 
-            fn send(tx: SyncSender<~int>, i: int) {
+            fn send(tx: SyncSender<Box<int>>, i: int) {
                 if i == 10 { return }
 
                 spawn(proc() {
@@ -1814,7 +1818,7 @@ mod sync_tests {
                 });
             }
 
-            fn recv(rx: Receiver<~int>, i: int) {
+            fn recv(rx: Receiver<Box<int>>, i: int) {
                 if i == 10 { return }
 
                 spawn(proc() {
diff --git a/src/libstd/comm/oneshot.rs b/src/libstd/comm/oneshot.rs
index e92b5cb272a..a7124e50b66 100644
--- a/src/libstd/comm/oneshot.rs
+++ b/src/libstd/comm/oneshot.rs
@@ -37,6 +37,7 @@ use kinds::Send;
 use mem;
 use ops::Drop;
 use option::{Some, None, Option};
+use owned::Box;
 use result::{Result, Ok, Err};
 use rt::local::Local;
 use rt::task::{Task, BlockedTask};
@@ -137,7 +138,7 @@ impl<T: Send> Packet<T> {
         // Attempt to not block the task (it's a little expensive). If it looks
         // like we're not empty, then immediately go through to `try_recv`.
         if self.state.load(atomics::SeqCst) == EMPTY {
-            let t: ~Task = Local::take();
+            let t: Box<Task> = Local::take();
             t.deschedule(1, |task| {
                 let n = unsafe { task.cast_to_uint() };
                 match self.state.compare_and_swap(EMPTY, n, atomics::SeqCst) {
diff --git a/src/libstd/comm/select.rs b/src/libstd/comm/select.rs
index c286fd84849..cebfeb5399e 100644
--- a/src/libstd/comm/select.rs
+++ b/src/libstd/comm/select.rs
@@ -52,6 +52,7 @@ use kinds::marker;
 use kinds::Send;
 use ops::Drop;
 use option::{Some, None, Option};
+use owned::Box;
 use ptr::RawPtr;
 use result::{Ok, Err, Result};
 use rt::local::Local;
@@ -176,7 +177,7 @@ impl Select {
             // Acquire a number of blocking contexts, and block on each one
             // sequentially until one fails. If one fails, then abort
             // immediately so we can go unblock on all the other receivers.
-            let task: ~Task = Local::take();
+            let task: Box<Task> = Local::take();
             task.deschedule(amt, |task| {
                 // Prepare for the block
                 let (i, handle) = iter.next().unwrap();
diff --git a/src/libstd/comm/shared.rs b/src/libstd/comm/shared.rs
index c0f1aeae26b..8aef2ec80a8 100644
--- a/src/libstd/comm/shared.rs
+++ b/src/libstd/comm/shared.rs
@@ -24,6 +24,7 @@ use iter::Iterator;
 use kinds::Send;
 use ops::Drop;
 use option::{Some, None, Option};
+use owned::Box;
 use result::{Ok, Err, Result};
 use rt::local::Local;
 use rt::task::{Task, BlockedTask};
@@ -223,7 +224,7 @@ impl<T: Send> Packet<T> {
             data => return data,
         }
 
-        let task: ~Task = Local::take();
+        let task: Box<Task> = Local::take();
         task.deschedule(1, |task| {
             self.decrement(task)
         });
diff --git a/src/libstd/comm/stream.rs b/src/libstd/comm/stream.rs
index 44070dc4460..9fb22ef4508 100644
--- a/src/libstd/comm/stream.rs
+++ b/src/libstd/comm/stream.rs
@@ -24,6 +24,7 @@ use iter::Iterator;
 use kinds::Send;
 use ops::Drop;
 use option::{Some, None};
+use owned::Box;
 use result::{Ok, Err, Result};
 use rt::local::Local;
 use rt::task::{Task, BlockedTask};
@@ -181,7 +182,7 @@ impl<T: Send> Packet<T> {
 
         // Welp, our channel has no data. Deschedule the current task and
         // initiate the blocking protocol.
-        let task: ~Task = Local::take();
+        let task: Box<Task> = Local::take();
         task.deschedule(1, |task| {
             self.decrement(task)
         });
diff --git a/src/libstd/comm/sync.rs b/src/libstd/comm/sync.rs
index 6228c4c682b..db3f90cad5a 100644
--- a/src/libstd/comm/sync.rs
+++ b/src/libstd/comm/sync.rs
@@ -40,6 +40,7 @@ use kinds::Send;
 use mem;
 use ops::Drop;
 use option::{Some, None, Option};
+use owned::Box;
 use ptr::RawPtr;
 use result::{Result, Ok, Err};
 use rt::local::Local;
@@ -111,7 +112,7 @@ pub enum Failure {
 /// in the meantime. This re-locks the mutex upon returning.
 fn wait(slot: &mut Blocker, f: fn(BlockedTask) -> Blocker,
         lock: &NativeMutex) {
-    let me: ~Task = Local::take();
+    let me: Box<Task> = Local::take();
     me.deschedule(1, |task| {
         match mem::replace(slot, f(task)) {
             NoneBlocked => {}
@@ -445,7 +446,7 @@ impl<T> Buffer<T> {
 
 impl Queue {
     fn enqueue(&mut self, lock: &NativeMutex) {
-        let task: ~Task = Local::take();
+        let task: Box<Task> = Local::take();
         let mut node = Node {
             task: None,
             next: 0 as *mut Node,
diff --git a/src/libstd/default.rs b/src/libstd/default.rs
index 8dcce3fd146..9cf3a763648 100644
--- a/src/libstd/default.rs
+++ b/src/libstd/default.rs
@@ -10,6 +10,8 @@
 
 //! The `Default` trait for types which may have meaningful default values
 
+use owned::Box;
+
 /// A trait that types which have a useful default value should implement.
 pub trait Default {
     /// Return the "default value" for a type.
@@ -20,6 +22,6 @@ impl<T: Default + 'static> Default for @T {
     fn default() -> @T { @Default::default() }
 }
 
-impl<T: Default> Default for ~T {
-    fn default() -> ~T { box Default::default() }
+impl<T: Default> Default for Box<T> {
+    fn default() -> Box<T> { box Default::default() }
 }
diff --git a/src/libstd/fmt/mod.rs b/src/libstd/fmt/mod.rs
index e225dc42e05..38456e195e3 100644
--- a/src/libstd/fmt/mod.rs
+++ b/src/libstd/fmt/mod.rs
@@ -492,6 +492,7 @@ use io;
 use iter::{Iterator, range};
 use num::Signed;
 use option::{Option,Some,None};
+use owned::Box;
 use repr;
 use result::{Ok, Err};
 use str::StrSlice;
@@ -1113,7 +1114,7 @@ pub fn argumentuint<'a>(s: &'a uint) -> Argument<'a> {
 impl<T: Show> Show for @T {
     fn fmt(&self, f: &mut Formatter) -> Result { secret_show(&**self, f) }
 }
-impl<T: Show> Show for ~T {
+impl<T: Show> Show for Box<T> {
     fn fmt(&self, f: &mut Formatter) -> Result { secret_show(&**self, f) }
 }
 impl<'a, T: Show> Show for &'a T {
diff --git a/src/libstd/fmt/parse.rs b/src/libstd/fmt/parse.rs
index 0ba8cff742b..ba126e00153 100644
--- a/src/libstd/fmt/parse.rs
+++ b/src/libstd/fmt/parse.rs
@@ -17,6 +17,7 @@
 use prelude::*;
 
 use char;
+use owned::Box;
 use str;
 
 /// A piece is a portion of the format string which represents the next part
@@ -41,7 +42,7 @@ pub struct Argument<'a> {
     /// How to format the argument
     pub format: FormatSpec<'a>,
     /// If not `None`, what method to invoke on the argument
-    pub method: Option<~Method<'a>>
+    pub method: Option<Box<Method<'a>>>
 }
 
 /// Specification for the formatting of an argument in the format string.
@@ -435,7 +436,7 @@ impl<'a> Parser<'a> {
 
     /// Parses a method to be applied to the previously specified argument and
     /// its format. The two current supported methods are 'plural' and 'select'
-    fn method(&mut self) -> Option<~Method<'a>> {
+    fn method(&mut self) -> Option<Box<Method<'a>>> {
         if !self.wsconsume(',') {
             return None;
         }
@@ -461,7 +462,7 @@ impl<'a> Parser<'a> {
     }
 
     /// Parses a 'select' statement (after the initial 'select' word)
-    fn select(&mut self) -> ~Method<'a> {
+    fn select(&mut self) -> Box<Method<'a>> {
         let mut other = None;
         let mut arms = vec!();
         // Consume arms one at a time
@@ -503,7 +504,7 @@ impl<'a> Parser<'a> {
     }
 
     /// Parses a 'plural' statement (after the initial 'plural' word)
-    fn plural(&mut self) -> ~Method<'a> {
+    fn plural(&mut self) -> Box<Method<'a>> {
         let mut offset = None;
         let mut other = None;
         let mut arms = vec!();
diff --git a/src/libstd/hash/mod.rs b/src/libstd/hash/mod.rs
index e8ca4037f57..748cf0eeed9 100644
--- a/src/libstd/hash/mod.rs
+++ b/src/libstd/hash/mod.rs
@@ -67,6 +67,7 @@ use container::Container;
 use io::Writer;
 use iter::Iterator;
 use option::{Option, Some, None};
+use owned::Box;
 use rc::Rc;
 use str::{Str, StrSlice};
 use slice::{Vector, ImmutableVector};
@@ -229,7 +230,7 @@ impl<'a, S: Writer, T: Hash<S>> Hash<S> for &'a mut T {
     }
 }
 
-impl<S: Writer, T: Hash<S>> Hash<S> for ~T {
+impl<S: Writer, T: Hash<S>> Hash<S> for Box<T> {
     #[inline]
     fn hash(&self, state: &mut S) {
         (**self).hash(state);
diff --git a/src/libstd/io/fs.rs b/src/libstd/io/fs.rs
index 6d48b9eee35..3f66ecd5db3 100644
--- a/src/libstd/io/fs.rs
+++ b/src/libstd/io/fs.rs
@@ -55,11 +55,12 @@ use container::Container;
 use iter::Iterator;
 use kinds::Send;
 use super::{Reader, Writer, Seek};
-use super::{SeekStyle, Read, Write, Open, IoError, Truncate,
-            FileMode, FileAccess, FileStat, IoResult, FilePermission};
+use super::{SeekStyle, Read, Write, Open, IoError, Truncate};
+use super::{FileMode, FileAccess, FileStat, IoResult, FilePermission};
 use rt::rtio::{RtioFileStream, IoFactory, LocalIo};
 use io;
 use option::{Some, None, Option};
+use owned::Box;
 use result::{Ok, Err};
 use path;
 use path::{Path, GenericPath};
@@ -78,7 +79,7 @@ use vec::Vec;
 /// configured at creation time, via the `FileAccess` parameter to
 /// `File::open_mode()`.
 pub struct File {
-    fd: ~RtioFileStream:Send,
+    fd: Box<RtioFileStream:Send>,
     path: Path,
     last_nread: int,
 }
diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
index ff276d02028..59a8c6f3439 100644
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -227,6 +227,7 @@ use libc;
 use ops::{BitOr, BitAnd, Sub};
 use os;
 use option::{Option, Some, None};
+use owned::Box;
 use path::Path;
 use result::{Ok, Err, Result};
 use str::StrSlice;
@@ -811,7 +812,7 @@ pub trait Reader {
     }
 }
 
-impl Reader for ~Reader {
+impl Reader for Box<Reader> {
     fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> { self.read(buf) }
 }
 
@@ -1052,7 +1053,7 @@ pub trait Writer {
     }
 }
 
-impl Writer for ~Writer {
+impl Writer for Box<Writer> {
     fn write(&mut self, buf: &[u8]) -> IoResult<()> { self.write(buf) }
     fn flush(&mut self) -> IoResult<()> { self.flush() }
 }
diff --git a/src/libstd/io/net/tcp.rs b/src/libstd/io/net/tcp.rs
index c6a8702b674..a2cd69da5ae 100644
--- a/src/libstd/io/net/tcp.rs
+++ b/src/libstd/io/net/tcp.rs
@@ -23,6 +23,7 @@ use io::net::ip::SocketAddr;
 use io::{Reader, Writer, Listener, Acceptor};
 use kinds::Send;
 use option::{None, Some, Option};
+use owned::Box;
 use rt::rtio::{IoFactory, LocalIo, RtioSocket, RtioTcpListener};
 use rt::rtio::{RtioTcpAcceptor, RtioTcpStream};
 
@@ -45,11 +46,11 @@ use rt::rtio::{RtioTcpAcceptor, RtioTcpStream};
 /// drop(stream); // close the connection
 /// ```
 pub struct TcpStream {
-    obj: ~RtioTcpStream:Send
+    obj: Box<RtioTcpStream:Send>,
 }
 
 impl TcpStream {
-    fn new(s: ~RtioTcpStream:Send) -> TcpStream {
+    fn new(s: Box<RtioTcpStream:Send>) -> TcpStream {
         TcpStream { obj: s }
     }
 
@@ -171,7 +172,7 @@ impl Writer for TcpStream {
 /// # }
 /// ```
 pub struct TcpListener {
-    obj: ~RtioTcpListener:Send
+    obj: Box<RtioTcpListener:Send>,
 }
 
 impl TcpListener {
@@ -204,7 +205,7 @@ impl Listener<TcpStream, TcpAcceptor> for TcpListener {
 /// a `TcpListener`'s `listen` method, and this object can be used to accept new
 /// `TcpStream` instances.
 pub struct TcpAcceptor {
-    obj: ~RtioTcpAcceptor:Send
+    obj: Box<RtioTcpAcceptor:Send>,
 }
 
 impl TcpAcceptor {
diff --git a/src/libstd/io/net/udp.rs b/src/libstd/io/net/udp.rs
index a9708ed5fa1..b5b0cf7bede 100644
--- a/src/libstd/io/net/udp.rs
+++ b/src/libstd/io/net/udp.rs
@@ -19,6 +19,7 @@ use clone::Clone;
 use io::net::ip::{SocketAddr, IpAddr};
 use io::{Reader, Writer, IoResult};
 use kinds::Send;
+use owned::Box;
 use result::{Ok, Err};
 use rt::rtio::{RtioSocket, RtioUdpSocket, IoFactory, LocalIo};
 
@@ -54,7 +55,7 @@ use rt::rtio::{RtioSocket, RtioUdpSocket, IoFactory, LocalIo};
 /// drop(socket); // close the socket
 /// ```
 pub struct UdpSocket {
-    obj: ~RtioUdpSocket:Send
+    obj: Box<RtioUdpSocket:Send>,
 }
 
 impl UdpSocket {
diff --git a/src/libstd/io/net/unix.rs b/src/libstd/io/net/unix.rs
index b75b797e974..f6e985dc278 100644
--- a/src/libstd/io/net/unix.rs
+++ b/src/libstd/io/net/unix.rs
@@ -31,6 +31,7 @@ use clone::Clone;
 use io::pipe::PipeStream;
 use io::{Listener, Acceptor, Reader, Writer, IoResult};
 use kinds::Send;
+use owned::Box;
 use rt::rtio::{IoFactory, LocalIo, RtioUnixListener};
 use rt::rtio::{RtioUnixAcceptor, RtioPipe};
 
@@ -40,7 +41,7 @@ pub struct UnixStream {
 }
 
 impl UnixStream {
-    fn new(obj: ~RtioPipe:Send) -> UnixStream {
+    fn new(obj: Box<RtioPipe:Send>) -> UnixStream {
         UnixStream { obj: PipeStream::new(obj) }
     }
 
@@ -107,7 +108,7 @@ impl Writer for UnixStream {
 /// A value that can listen for incoming named pipe connection requests.
 pub struct UnixListener {
     /// The internal, opaque runtime Unix listener.
-    obj: ~RtioUnixListener:Send,
+    obj: Box<RtioUnixListener:Send>,
 }
 
 impl UnixListener {
@@ -149,7 +150,7 @@ impl Listener<UnixStream, UnixAcceptor> for UnixListener {
 /// A value that can accept named pipe connections, returned from `listen()`.
 pub struct UnixAcceptor {
     /// The internal, opaque runtime Unix acceptor.
-    obj: ~RtioUnixAcceptor:Send,
+    obj: Box<RtioUnixAcceptor:Send>,
 }
 
 impl UnixAcceptor {
diff --git a/src/libstd/io/pipe.rs b/src/libstd/io/pipe.rs
index 77a97f4e259..fbb0d5bc8d8 100644
--- a/src/libstd/io/pipe.rs
+++ b/src/libstd/io/pipe.rs
@@ -18,12 +18,13 @@
 use prelude::*;
 use io::IoResult;
 use libc;
+use owned::Box;
 use rt::rtio::{RtioPipe, LocalIo};
 
 /// A synchronous, in-memory pipe.
 pub struct PipeStream {
     /// The internal, opaque runtime pipe object.
-    obj: ~RtioPipe:Send,
+    obj: Box<RtioPipe:Send>,
 }
 
 impl PipeStream {
@@ -54,7 +55,7 @@ impl PipeStream {
     }
 
     #[doc(hidden)]
-    pub fn new(inner: ~RtioPipe:Send) -> PipeStream {
+    pub fn new(inner: Box<RtioPipe:Send>) -> PipeStream {
         PipeStream { obj: inner }
     }
 }
diff --git a/src/libstd/io/process.rs b/src/libstd/io/process.rs
index b89e3ec3c77..1471a049bf3 100644
--- a/src/libstd/io/process.rs
+++ b/src/libstd/io/process.rs
@@ -17,6 +17,7 @@ use io::IoResult;
 use io;
 use libc;
 use mem;
+use owned::Box;
 use rt::rtio::{RtioProcess, IoFactory, LocalIo};
 
 /// Signal a process to exit, without forcibly killing it. Corresponds to
@@ -52,7 +53,7 @@ use rt::rtio::{RtioProcess, IoFactory, LocalIo};
 /// assert!(child.wait().success());
 /// ```
 pub struct Process {
-    handle: ~RtioProcess:Send,
+    handle: Box<RtioProcess:Send>,
 
     /// Handle to the child's stdin, if the `stdin` field of this process's
     /// `ProcessConfig` was `CreatePipe`. By default, this handle is `Some`.
diff --git a/src/libstd/io/signal.rs b/src/libstd/io/signal.rs
index e7dae59acb8..4d294e84070 100644
--- a/src/libstd/io/signal.rs
+++ b/src/libstd/io/signal.rs
@@ -26,6 +26,7 @@ use iter::Iterator;
 use kinds::Send;
 use mem::drop;
 use option::{Some, None};
+use owned::Box;
 use result::{Ok, Err};
 use rt::rtio::{IoFactory, LocalIo, RtioSignal};
 use slice::ImmutableVector;
@@ -81,7 +82,7 @@ pub enum Signum {
 /// ```
 pub struct Listener {
     /// A map from signums to handles to keep the handles in memory
-    handles: Vec<(Signum, ~RtioSignal:Send)>,
+    handles: Vec<(Signum, Box<RtioSignal:Send>)>,
     /// This is where all the handles send signums, which are received by
     /// the clients from the receiver.
     tx: Sender<Signum>,
diff --git a/src/libstd/io/stdio.rs b/src/libstd/io/stdio.rs
index 7cb58e1ea48..613e9f027a4 100644
--- a/src/libstd/io/stdio.rs
+++ b/src/libstd/io/stdio.rs
@@ -34,6 +34,7 @@ use libc;
 use kinds::Send;
 use mem::replace;
 use option::{Option, Some, None};
+use owned::Box;
 use prelude::drop;
 use result::{Ok, Err};
 use rt;
@@ -71,8 +72,8 @@ use str::StrSlice;
 // tl;dr; TTY works on everything but when windows stdout is redirected, in that
 //        case pipe also doesn't work, but magically file does!
 enum StdSource {
-    TTY(~RtioTTY:Send),
-    File(~RtioFileStream:Send),
+    TTY(Box<RtioTTY:Send>),
+    File(Box<RtioFileStream:Send>),
 }
 
 fn src<T>(fd: libc::c_int, readable: bool, f: |StdSource| -> T) -> T {
@@ -153,10 +154,9 @@ pub fn stderr_raw() -> StdWriter {
     src(libc::STDERR_FILENO, false, |src| StdWriter { inner: src })
 }
 
-fn reset_helper(w: ~Writer:Send,
-                f: |&mut Task, ~Writer:Send| -> Option<~Writer:Send>)
-    -> Option<~Writer:Send>
-{
+fn reset_helper(w: Box<Writer:Send>,
+                f: |&mut Task, Box<Writer:Send>| -> Option<Box<Writer:Send>>)
+                -> Option<Box<Writer:Send>> {
     let mut t = Local::borrow(None::<Task>);
     // Be sure to flush any pending output from the writer
     match f(&mut *t, w) {
@@ -178,7 +178,7 @@ fn reset_helper(w: ~Writer:Send,
 ///
 /// Note that this does not need to be called for all new tasks; the default
 /// output handle is to the process's stdout stream.
-pub fn set_stdout(stdout: ~Writer:Send) -> Option<~Writer:Send> {
+pub fn set_stdout(stdout: Box<Writer:Send>) -> Option<Box<Writer:Send>> {
     reset_helper(stdout, |t, w| replace(&mut t.stdout, Some(w)))
 }
 
@@ -190,7 +190,7 @@ pub fn set_stdout(stdout: ~Writer:Send) -> Option<~Writer:Send> {
 ///
 /// Note that this does not need to be called for all new tasks; the default
 /// output handle is to the process's stderr stream.
-pub fn set_stderr(stderr: ~Writer:Send) -> Option<~Writer:Send> {
+pub fn set_stderr(stderr: Box<Writer:Send>) -> Option<Box<Writer:Send>> {
     reset_helper(stderr, |t, w| replace(&mut t.stderr, Some(w)))
 }
 
@@ -205,7 +205,7 @@ pub fn set_stderr(stderr: ~Writer:Send) -> Option<~Writer:Send> {
 //      })
 //  })
 fn with_task_stdout(f: |&mut Writer| -> IoResult<()> ) {
-    let task: Option<~Task> = Local::try_take();
+    let task: Option<Box<Task>> = Local::try_take();
     let result = match task {
         Some(mut task) => {
             // Printing may run arbitrary code, so ensure that the task is in
@@ -216,7 +216,7 @@ fn with_task_stdout(f: |&mut Writer| -> IoResult<()> ) {
             Local::put(task);
 
             if my_stdout.is_none() {
-                my_stdout = Some(box stdout() as ~Writer:Send);
+                my_stdout = Some(box stdout() as Box<Writer:Send>);
             }
             let ret = f(*my_stdout.get_mut_ref());
 
diff --git a/src/libstd/io/timer.rs b/src/libstd/io/timer.rs
index 1ca36df968c..96c4083e7ed 100644
--- a/src/libstd/io/timer.rs
+++ b/src/libstd/io/timer.rs
@@ -20,6 +20,7 @@ and create receivers which will receive notifications after a period of time.
 use comm::Receiver;
 use io::IoResult;
 use kinds::Send;
+use owned::Box;
 use rt::rtio::{IoFactory, LocalIo, RtioTimer};
 
 /// A synchronous timer object
@@ -63,7 +64,7 @@ use rt::rtio::{IoFactory, LocalIo, RtioTimer};
 /// # }
 /// ```
 pub struct Timer {
-    obj: ~RtioTimer:Send,
+    obj: Box<RtioTimer:Send>,
 }
 
 /// Sleep the current task for `msecs` milliseconds.
diff --git a/src/libstd/io/util.rs b/src/libstd/io/util.rs
index 5cae79d371f..b2e6b27caab 100644
--- a/src/libstd/io/util.rs
+++ b/src/libstd/io/util.rs
@@ -13,6 +13,7 @@
 use prelude::*;
 use cmp;
 use io;
+use owned::Box;
 use slice::bytes::MutableByteVector;
 
 /// Wraps a `Reader`, limiting the number of bytes that can be read from it.
@@ -85,12 +86,12 @@ impl Reader for NullReader {
 
 /// A `Writer` which multiplexes writes to a set of `Writers`.
 pub struct MultiWriter {
-    writers: Vec<~Writer>
+    writers: Vec<Box<Writer>>
 }
 
 impl MultiWriter {
     /// Creates a new `MultiWriter`
-    pub fn new(writers: Vec<~Writer>) -> MultiWriter {
+    pub fn new(writers: Vec<Box<Writer>>) -> MultiWriter {
         MultiWriter { writers: writers }
     }
 }
@@ -199,6 +200,7 @@ pub fn copy<R: Reader, W: Writer>(r: &mut R, w: &mut W) -> io::IoResult<()> {
 mod test {
     use io;
     use io::{MemReader, MemWriter};
+    use owned::Box;
     use super::*;
     use prelude::*;
 
@@ -273,8 +275,8 @@ mod test {
             }
         }
 
-        let mut multi = MultiWriter::new(vec!(box TestWriter as ~Writer,
-                                              box TestWriter as ~Writer));
+        let mut multi = MultiWriter::new(vec!(box TestWriter as Box<Writer>,
+                                              box TestWriter as Box<Writer>));
         multi.write([1, 2, 3]).unwrap();
         assert_eq!(2, unsafe { writes });
         assert_eq!(0, unsafe { flushes });
diff --git a/src/libstd/iter.rs b/src/libstd/iter.rs
index 3e6f55e8251..7dc1252fc77 100644
--- a/src/libstd/iter.rs
+++ b/src/libstd/iter.rs
@@ -2333,6 +2333,7 @@ mod tests {
     use prelude::*;
 
     use cmp;
+    use owned::Box;
     use uint;
     use num;
 
@@ -2634,7 +2635,7 @@ mod tests {
 
     #[test]
     fn test_all() {
-        let v: ~&[int] = box &[1, 2, 3, 4, 5];
+        let v: Box<&[int]> = box &[1, 2, 3, 4, 5];
         assert!(v.iter().all(|&x| x < 10));
         assert!(!v.iter().all(|&x| x % 2 == 0));
         assert!(!v.iter().all(|&x| x > 100));
@@ -2643,7 +2644,7 @@ mod tests {
 
     #[test]
     fn test_any() {
-        let v: ~&[int] = box &[1, 2, 3, 4, 5];
+        let v: Box<&[int]> = box &[1, 2, 3, 4, 5];
         assert!(v.iter().any(|&x| x < 10));
         assert!(v.iter().any(|&x| x % 2 == 0));
         assert!(!v.iter().any(|&x| x > 100));
diff --git a/src/libstd/kinds.rs b/src/libstd/kinds.rs
index f9827d7fa59..6ef71d3360a 100644
--- a/src/libstd/kinds.rs
+++ b/src/libstd/kinds.rs
@@ -48,7 +48,7 @@ pub trait Copy {
 /// `Share`, and so are simple aggregate types containing them (like
 /// tuples, structs and enums). More instances of basic `Share` types
 /// include "immutable" types like `&T` and those with simple
-/// inherited mutability, such as `~T`, `Vec<T>` and most other
+/// inherited mutability, such as `Box<T>`, `Vec<T>` and most other
 /// collection types. (Generic parameters need to be `Share` for their
 /// container to be `Share`.)
 ///
diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs
index c34ebfdf7c2..bf24bf405a0 100644
--- a/src/libstd/lib.rs
+++ b/src/libstd/lib.rs
@@ -131,6 +131,7 @@ extern crate libc;
 #[cfg(test)] pub use ops = realstd::ops;
 #[cfg(test)] pub use cmp = realstd::cmp;
 #[cfg(test)] pub use ty = realstd::ty;
+#[cfg(test)] pub use owned = realstd::owned;
 
 // Run tests with libgreen instead of libnative.
 //
@@ -188,7 +189,6 @@ pub mod strbuf;
 pub mod ascii;
 
 pub mod ptr;
-pub mod owned;
 mod managed;
 mod reference;
 pub mod rc;
@@ -201,6 +201,7 @@ pub mod gc;
 #[cfg(not(test))] pub mod ops;
 #[cfg(not(test))] pub mod cmp;
 #[cfg(not(test))] pub mod ty;
+#[cfg(not(test))] pub mod owned;
 
 
 /* Common traits */
diff --git a/src/libstd/local_data.rs b/src/libstd/local_data.rs
index 635b729314f..9a029de8d6c 100644
--- a/src/libstd/local_data.rs
+++ b/src/libstd/local_data.rs
@@ -45,6 +45,7 @@ use iter::{Iterator};
 use kinds::Send;
 use mem::replace;
 use option::{None, Option, Some};
+use owned::Box;
 use rt::task::{Task, LocalStorage};
 use slice::{ImmutableVector, MutableVector};
 use vec::Vec;
@@ -91,7 +92,7 @@ impl<T: 'static> LocalData for T {}
 //      a proper map.
 #[doc(hidden)]
 pub type Map = Vec<Option<(*u8, TLSValue, LoanState)>>;
-type TLSValue = ~LocalData:Send;
+type TLSValue = Box<LocalData:Send>;
 
 // Gets the map from the runtime. Lazily initialises if not done so already.
 unsafe fn get_local_map() -> &mut Map {
@@ -161,7 +162,7 @@ pub fn pop<T: 'static>(key: Key<T>) -> Option<T> {
 
                 // Move `data` into transmute to get out the memory that it
                 // owns, we must free it manually later.
-                let (_vtable, alloc): (uint, ~T) = unsafe {
+                let (_vtable, alloc): (uint, Box<T>) = unsafe {
                     cast::transmute(data)
                 };
 
@@ -252,11 +253,12 @@ fn get_with<T:'static,
                                   want.describe(), cur.describe());
                         }
                     }
-                    // data was created with `~T as ~LocalData`, so we extract
-                    // pointer part of the trait, (as ~T), and then use
-                    // compiler coercions to achieve a '&' pointer.
+                    // data was created with `box T as Box<LocalData>`, so we
+                    // extract pointer part of the trait, (as Box<T>), and
+                    // then use compiler coercions to achieve a '&' pointer.
                     unsafe {
-                        match *cast::transmute::<&TLSValue, &(uint, ~T)>(data){
+                        match *cast::transmute::<&TLSValue,
+                                                 &(uint, Box<T>)>(data){
                             (_vtable, ref alloc) => {
                                 let value: &T = *alloc;
                                 ret = f(Some(value));
@@ -297,12 +299,12 @@ pub fn set<T: 'static>(key: Key<T>, data: T) {
     let keyval = key_to_key_value(key);
 
     // When the task-local map is destroyed, all the data needs to be cleaned
-    // up. For this reason we can't do some clever tricks to store '~T' as a
-    // '*c_void' or something like that. To solve the problem, we cast
+    // up. For this reason we can't do some clever tricks to store 'Box<T>' as
+    // a '*c_void' or something like that. To solve the problem, we cast
     // everything to a trait (LocalData) which is then stored inside the map.
     // Upon destruction of the map, all the objects will be destroyed and the
     // traits have enough information about them to destroy themselves.
-    let data = box data as ~LocalData:;
+    let data = box data as Box<LocalData:>;
 
     fn insertion_position(map: &mut Map,
                           key: *u8) -> Option<uint> {
@@ -330,7 +332,7 @@ pub fn set<T: 'static>(key: Key<T>, data: T) {
     // transmute here to add the Send bound back on. This doesn't actually
     // matter because TLS will always own the data (until its moved out) and
     // we're not actually sending it to other schedulers or anything.
-    let data: ~LocalData:Send = unsafe { cast::transmute(data) };
+    let data: Box<LocalData:Send> = unsafe { cast::transmute(data) };
     match insertion_position(map, keyval) {
         Some(i) => { *map.get_mut(i) = Some((keyval, data, NoLoan)); }
         None => { map.push(Some((keyval, data, NoLoan))); }
@@ -353,6 +355,7 @@ pub fn modify<T: 'static>(key: Key<T>, f: |Option<T>| -> Option<T>) {
 mod tests {
     use prelude::*;
     use super::*;
+    use owned::Box;
     use task;
     use str::StrSlice;
 
@@ -485,7 +488,7 @@ mod tests {
 
     #[test]
     fn test_owned() {
-        static key: Key<~int> = &Key;
+        static key: Key<Box<int>> = &Key;
         set(key, box 1);
 
         get(key, |v| {
diff --git a/src/libstd/macros.rs b/src/libstd/macros.rs
index b04ca63e55e..4ae3d453f03 100644
--- a/src/libstd/macros.rs
+++ b/src/libstd/macros.rs
@@ -19,9 +19,9 @@
 /// The entry point for failure of rust tasks.
 ///
 /// This macro is used to inject failure into a rust task, causing the task to
-/// unwind and fail entirely. Each task's failure can be reaped as the `~Any`
-/// type, and the single-argument form of the `fail!` macro will be the value
-/// which is transmitted.
+/// unwind and fail entirely. Each task's failure can be reaped as the
+/// `Box<Any>` type, and the single-argument form of the `fail!` macro will be
+/// the value which is transmitted.
 ///
 /// The multi-argument form of this macro fails with a string and has the
 /// `format!` syntax for building a string.
diff --git a/src/libstd/option.rs b/src/libstd/option.rs
index eabaf4f2f9a..fa7b5c94857 100644
--- a/src/libstd/option.rs
+++ b/src/libstd/option.rs
@@ -54,7 +54,7 @@
 //!
 //! Rust's pointer types must always point to a valid location; there are
 //! no "null" pointers. Instead, Rust has *optional* pointers, like
-//! the optional owned box, `Option<~T>`.
+//! the optional owned box, `Option<Box<T>>`.
 //!
 //! The following example uses `Option` to create an optional box of
 //! `int`. Notice that in order to use the inner `int` value first the
@@ -63,13 +63,13 @@
 //! not (`None`).
 //!
 //! ```
-//! let optional: Option<~int> = None;
+//! let optional: Option<Box<int>> = None;
 //! check_optional(&optional);
 //!
-//! let optional: Option<~int> = Some(~9000);
+//! let optional: Option<Box<int>> = Some(box 9000);
 //! check_optional(&optional);
 //!
-//! fn check_optional(optional: &Option<~int>) {
+//! fn check_optional(optional: &Option<Box<int>>) {
 //!     match *optional {
 //!         Some(ref p) => println!("have value {}", p),
 //!         None => println!("have no value")
@@ -79,7 +79,7 @@
 //!
 //! This usage of `Option` to create safe nullable pointers is so
 //! common that Rust does special optimizations to make the
-//! representation of `Option<~T>` a single pointer. Optional pointers
+//! representation of `Option<Box<T>>` a single pointer. Optional pointers
 //! in Rust are stored as efficiently as any other pointer type.
 //!
 //! # Examples
diff --git a/src/libstd/owned.rs b/src/libstd/owned.rs
index 826ada8f252..48b80e0ca8e 100644
--- a/src/libstd/owned.rs
+++ b/src/libstd/owned.rs
@@ -35,30 +35,30 @@ pub struct Box<T>(*T);
 pub struct Box<T>(*T);
 
 #[cfg(not(test))]
-impl<T:Eq> Eq for ~T {
+impl<T:Eq> Eq for Box<T> {
     #[inline]
-    fn eq(&self, other: &~T) -> bool { *(*self) == *(*other) }
+    fn eq(&self, other: &Box<T>) -> bool { *(*self) == *(*other) }
     #[inline]
-    fn ne(&self, other: &~T) -> bool { *(*self) != *(*other) }
+    fn ne(&self, other: &Box<T>) -> bool { *(*self) != *(*other) }
 }
 
 #[cfg(not(test))]
-impl<T:Ord> Ord for ~T {
+impl<T:Ord> Ord for Box<T> {
     #[inline]
-    fn lt(&self, other: &~T) -> bool { *(*self) < *(*other) }
+    fn lt(&self, other: &Box<T>) -> bool { *(*self) < *(*other) }
     #[inline]
-    fn le(&self, other: &~T) -> bool { *(*self) <= *(*other) }
+    fn le(&self, other: &Box<T>) -> bool { *(*self) <= *(*other) }
     #[inline]
-    fn ge(&self, other: &~T) -> bool { *(*self) >= *(*other) }
+    fn ge(&self, other: &Box<T>) -> bool { *(*self) >= *(*other) }
     #[inline]
-    fn gt(&self, other: &~T) -> bool { *(*self) > *(*other) }
+    fn gt(&self, other: &Box<T>) -> bool { *(*self) > *(*other) }
 }
 
 #[cfg(not(test))]
-impl<T: TotalOrd> TotalOrd for ~T {
+impl<T: TotalOrd> TotalOrd for Box<T> {
     #[inline]
-    fn cmp(&self, other: &~T) -> Ordering { (**self).cmp(*other) }
+    fn cmp(&self, other: &Box<T>) -> Ordering { (**self).cmp(*other) }
 }
 
 #[cfg(not(test))]
-impl<T: TotalEq> TotalEq for ~T {}
+impl<T: TotalEq> TotalEq for Box<T> {}
diff --git a/src/libstd/prelude.rs b/src/libstd/prelude.rs
index 32df3869534..ee1d5d4a35b 100644
--- a/src/libstd/prelude.rs
+++ b/src/libstd/prelude.rs
@@ -65,6 +65,7 @@ pub use iter::{OrdIterator, MutableDoubleEndedIterator, ExactSize};
 pub use num::{Num, NumCast, CheckedAdd, CheckedSub, CheckedMul};
 pub use num::{Signed, Unsigned};
 pub use num::{Primitive, Int, Float, ToPrimitive, FromPrimitive};
+pub use owned::Box;
 pub use path::{GenericPath, Path, PosixPath, WindowsPath};
 pub use ptr::RawPtr;
 pub use io::{Buffer, Writer, Reader, Seek};
diff --git a/src/libstd/ptr.rs b/src/libstd/ptr.rs
index b4b5185c221..dac727c2aa4 100644
--- a/src/libstd/ptr.rs
+++ b/src/libstd/ptr.rs
@@ -41,11 +41,11 @@
 //! and requires no resource management later,
 //! but you must not use the pointer after its lifetime.
 //!
-//! ## 2. Transmute an owned box (`~T`).
+//! ## 2. Transmute an owned box (`Box<T>`).
 //!
 //! The `transmute` function takes, by value, whatever it's given
 //! and returns it as whatever type is requested, as long as the
-//! types are the same size. Because `~T` and `*T` have the same
+//! types are the same size. Because `Box<T>` and `*T` have the same
 //! representation they can be trivially,
 //! though unsafely, transformed from one type to the other.
 //!
@@ -53,15 +53,15 @@
 //! use std::cast;
 //!
 //! unsafe {
-//!     let my_num: ~int = ~10;
+//!     let my_num: Box<int> = box 10;
 //!     let my_num: *int = cast::transmute(my_num);
-//!     let my_speed: ~int = ~88;
+//!     let my_speed: Box<int> = box 88;
 //!     let my_speed: *mut int = cast::transmute(my_speed);
 //!
-//!     // By taking ownership of the original `~T` though
+//!     // By taking ownership of the original `Box<T>` though
 //!     // we are obligated to transmute it back later to be destroyed.
-//!     drop(cast::transmute::<_, ~int>(my_speed));
-//!     drop(cast::transmute::<_, ~int>(my_num));
+//!     drop(cast::transmute::<_, Box<int>>(my_speed));
+//!     drop(cast::transmute::<_, Box<int>>(my_num));
 //! }
 //! ```
 //!
diff --git a/src/libstd/reflect.rs b/src/libstd/reflect.rs
index ddfc5b58532..ec7b6cfa355 100644
--- a/src/libstd/reflect.rs
+++ b/src/libstd/reflect.rs
@@ -18,6 +18,7 @@ Runtime type reflection
 
 use intrinsics::{Disr, Opaque, TyDesc, TyVisitor};
 use mem;
+use owned::Box;
 
 /**
  * Trait for visitor that wishes to reflect on data. To use this, create a
@@ -225,9 +226,9 @@ impl<V:TyVisitor + MovePtr> TyVisitor for MovePtrAdaptor<V> {
     }
 
     fn visit_uniq(&mut self, mtbl: uint, inner: *TyDesc) -> bool {
-        self.align_to::<~u8>();
+        self.align_to::<Box<u8>>();
         if ! self.inner.visit_uniq(mtbl, inner) { return false; }
-        self.bump_past::<~u8>();
+        self.bump_past::<Box<u8>>();
         true
     }
 
@@ -417,9 +418,9 @@ impl<V:TyVisitor + MovePtr> TyVisitor for MovePtrAdaptor<V> {
     }
 
     fn visit_trait(&mut self, name: &str) -> bool {
-        self.align_to::<~TyVisitor>();
+        self.align_to::<Box<TyVisitor>>();
         if ! self.inner.visit_trait(name) { return false; }
-        self.bump_past::<~TyVisitor>();
+        self.bump_past::<Box<TyVisitor>>();
         true
     }
 
diff --git a/src/libstd/repr.rs b/src/libstd/repr.rs
index cdcd7c23215..79b927c8d77 100644
--- a/src/libstd/repr.rs
+++ b/src/libstd/repr.rs
@@ -320,7 +320,7 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
     }
 
     fn visit_uniq(&mut self, _mtbl: uint, inner: *TyDesc) -> bool {
-        try!(self, self.writer.write(['~' as u8]));
+        try!(self, self.writer.write("box ".as_bytes()));
         self.get::<*u8>(|this, b| {
             this.visit_ptr_inner(*b, inner)
         })
@@ -353,7 +353,7 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
 
     fn visit_evec_uniq(&mut self, mtbl: uint, inner: *TyDesc) -> bool {
         self.get::<&raw::Vec<()>>(|this, b| {
-            try!(this, this.writer.write(['~' as u8]));
+            try!(this, this.writer.write("box ".as_bytes()));
             this.write_unboxed_vec_repr(mtbl, *b, inner)
         })
     }
@@ -624,6 +624,7 @@ fn test_repr() {
     use io::stdio::println;
     use char::is_alphabetic;
     use mem::swap;
+    use owned::Box;
 
     fn exact_test<T>(t: &T, e:&str) {
         let mut m = io::MemWriter::new();
@@ -641,7 +642,7 @@ fn test_repr() {
     exact_test(&("he\u10f3llo".to_owned()), "~\"he\\u10f3llo\"");
 
     exact_test(&(@10), "@10");
-    exact_test(&(box 10), "~10");
+    exact_test(&(box 10), "box 10");
     exact_test(&(&10), "&10");
     let mut x = 10;
     exact_test(&(&mut x), "&mut 10");
@@ -650,8 +651,6 @@ fn test_repr() {
     exact_test(&(0 as *mut ()), "(0x0 as *mut ())");
 
     exact_test(&(1,), "(1,)");
-    exact_test(&(box ["hi", "there"]),
-               "~[\"hi\", \"there\"]");
     exact_test(&(&["hi", "there"]),
                "&[\"hi\", \"there\"]");
     exact_test(&(P{a:10, b:1.234}),
@@ -659,7 +658,7 @@ fn test_repr() {
     exact_test(&(@P{a:10, b:1.234}),
                "@repr::P{a: 10, b: 1.234f64}");
     exact_test(&(box P{a:10, b:1.234}),
-               "~repr::P{a: 10, b: 1.234f64}");
+               "box repr::P{a: 10, b: 1.234f64}");
     exact_test(&(10u8, "hello".to_owned()),
                "(10u8, ~\"hello\")");
     exact_test(&(10u16, "hello".to_owned()),
@@ -680,10 +679,6 @@ fn test_repr() {
     exact_test(&println, "fn(&str)");
     exact_test(&swap::<int>, "fn(&mut int, &mut int)");
     exact_test(&is_alphabetic, "fn(char) -> bool");
-    exact_test(&(box 5 as ~ToStr), "~to_str::ToStr<no-bounds>");
-
-    struct Foo;
-    exact_test(&(box [Foo, Foo]), "~[repr::test_repr::Foo, repr::test_repr::Foo]");
 
     struct Bar(int, int);
     exact_test(&(Bar(2, 2)), "repr::test_repr::Bar(2, 2)");
diff --git a/src/libstd/rt/args.rs b/src/libstd/rt/args.rs
index 092efcad831..17e6f6b7698 100644
--- a/src/libstd/rt/args.rs
+++ b/src/libstd/rt/args.rs
@@ -67,6 +67,7 @@ mod imp {
     use clone::Clone;
     use option::{Option, Some, None};
     use iter::Iterator;
+    use owned::Box;
     use unstable::mutex::{StaticNativeMutex, NATIVE_MUTEX_INIT};
     use mem;
     #[cfg(not(test))] use str::StrSlice;
@@ -91,7 +92,7 @@ mod imp {
         with_lock(|| unsafe {
             let ptr = get_global_ptr();
             let val = mem::replace(&mut *ptr, None);
-            val.as_ref().map(|s: &~~[~[u8]]| (**s).clone())
+            val.as_ref().map(|s: &Box<~[~[u8]]>| (**s).clone())
         })
     }
 
@@ -106,7 +107,7 @@ mod imp {
     pub fn clone() -> Option<~[~[u8]]> {
         with_lock(|| unsafe {
             let ptr = get_global_ptr();
-            (*ptr).as_ref().map(|s: &~~[~[u8]]| (**s).clone())
+            (*ptr).as_ref().map(|s: &Box<~[~[u8]]>| (**s).clone())
         })
     }
 
@@ -117,7 +118,7 @@ mod imp {
         }
     }
 
-    fn get_global_ptr() -> *mut Option<~~[~[u8]]> {
+    fn get_global_ptr() -> *mut Option<Box<~[~[u8]]>> {
         unsafe { cast::transmute(&global_args_ptr) }
     }
 
diff --git a/src/libstd/rt/at_exit_imp.rs b/src/libstd/rt/at_exit_imp.rs
index 2c8e159aeb9..051bc494adc 100644
--- a/src/libstd/rt/at_exit_imp.rs
+++ b/src/libstd/rt/at_exit_imp.rs
@@ -17,6 +17,7 @@ use iter::Iterator;
 use kinds::Send;
 use mem;
 use option::{Some, None};
+use owned::Box;
 use ptr::RawPtr;
 use unstable::sync::Exclusive;
 use slice::OwnedVector;
@@ -36,7 +37,7 @@ pub fn init() {
     unsafe {
         rtassert!(!RUNNING);
         rtassert!(QUEUE.is_null());
-        let state: ~Queue = box Exclusive::new(vec!());
+        let state: Box<Queue> = box Exclusive::new(vec!());
         QUEUE = cast::transmute(state);
     }
 }
@@ -58,7 +59,7 @@ pub fn run() {
         rtassert!(!RUNNING);
         rtassert!(!QUEUE.is_null());
         RUNNING = true;
-        let state: ~Queue = cast::transmute(QUEUE);
+        let state: Box<Queue> = cast::transmute(QUEUE);
         QUEUE = 0 as *mut Queue;
         let mut vec = None;
         state.with(|arr| {
diff --git a/src/libstd/rt/backtrace.rs b/src/libstd/rt/backtrace.rs
index 26494f1acd9..ee8041f6880 100644
--- a/src/libstd/rt/backtrace.rs
+++ b/src/libstd/rt/backtrace.rs
@@ -129,7 +129,7 @@ fn demangle(writer: &mut Writer, s: &str) -> IoResult<()> {
                     // see src/librustc/back/link.rs for these mappings
                     demangle! (
                         "$SP$" => "@",
-                        "$UP$" => "~",
+                        "$UP$" => "Box",
                         "$RP$" => "*",
                         "$BP$" => "&",
                         "$LT$" => "<",
@@ -858,15 +858,15 @@ mod test {
 
     #[test]
     fn demangle_dollars() {
-        t!("_ZN4$UP$E", "~");
-        t!("_ZN8$UP$testE", "~test");
-        t!("_ZN8$UP$test4foobE", "~test::foob");
+        t!("_ZN4$UP$E", "Box");
+        t!("_ZN8$UP$testE", "Boxtest");
+        t!("_ZN8$UP$test4foobE", "Boxtest::foob");
         t!("_ZN8$x20test4foobE", " test::foob");
     }
 
     #[test]
     fn demangle_many_dollars() {
         t!("_ZN12test$x20test4foobE", "test test::foob");
-        t!("_ZN12test$UP$test4foobE", "test~test::foob");
+        t!("_ZN12test$UP$test4foobE", "testBoxtest::foob");
     }
 }
diff --git a/src/libstd/rt/global_heap.rs b/src/libstd/rt/global_heap.rs
index 094bbd13889..7d54c3faf42 100644
--- a/src/libstd/rt/global_heap.rs
+++ b/src/libstd/rt/global_heap.rs
@@ -72,9 +72,10 @@ pub unsafe fn realloc_raw(ptr: *mut u8, size: uint) -> *mut u8 {
 #[lang="exchange_malloc"]
 #[inline]
 pub unsafe fn exchange_malloc(size: uint) -> *mut u8 {
-    // The compiler never calls `exchange_free` on ~ZeroSizeType, so zero-size
-    // allocations can point to this `static`. It would be incorrect to use a null
-    // pointer, due to enums assuming types like unique pointers are never null.
+    // The compiler never calls `exchange_free` on Box<ZeroSizeType>, so
+    // zero-size allocations can point to this `static`. It would be incorrect
+    // to use a null pointer, due to enums assuming types like unique pointers
+    // are never null.
     static EMPTY: () = ();
 
     if size == 0 {
diff --git a/src/libstd/rt/local.rs b/src/libstd/rt/local.rs
index 828bbc118c1..05d1f1764b5 100644
--- a/src/libstd/rt/local.rs
+++ b/src/libstd/rt/local.rs
@@ -9,17 +9,18 @@
 // except according to those terms.
 
 use option::Option;
+use owned::Box;
 use rt::task::Task;
 use rt::local_ptr;
 
 /// Encapsulates some task-local data.
 pub trait Local<Borrowed> {
-    fn put(value: ~Self);
-    fn take() -> ~Self;
-    fn try_take() -> Option<~Self>;
+    fn put(value: Box<Self>);
+    fn take() -> Box<Self>;
+    fn try_take() -> Option<Box<Self>>;
     fn exists(unused_value: Option<Self>) -> bool;
     fn borrow(unused_value: Option<Self>) -> Borrowed;
-    unsafe fn unsafe_take() -> ~Self;
+    unsafe fn unsafe_take() -> Box<Self>;
     unsafe fn unsafe_borrow() -> *mut Self;
     unsafe fn try_unsafe_borrow() -> Option<*mut Self>;
 }
@@ -27,11 +28,11 @@ pub trait Local<Borrowed> {
 #[allow(visible_private_types)]
 impl Local<local_ptr::Borrowed<Task>> for Task {
     #[inline]
-    fn put(value: ~Task) { unsafe { local_ptr::put(value) } }
+    fn put(value: Box<Task>) { unsafe { local_ptr::put(value) } }
     #[inline]
-    fn take() -> ~Task { unsafe { local_ptr::take() } }
+    fn take() -> Box<Task> { unsafe { local_ptr::take() } }
     #[inline]
-    fn try_take() -> Option<~Task> { unsafe { local_ptr::try_take() } }
+    fn try_take() -> Option<Box<Task>> { unsafe { local_ptr::try_take() } }
     fn exists(_: Option<Task>) -> bool { local_ptr::exists() }
     #[inline]
     fn borrow(_: Option<Task>) -> local_ptr::Borrowed<Task> {
@@ -40,7 +41,7 @@ impl Local<local_ptr::Borrowed<Task>> for Task {
         }
     }
     #[inline]
-    unsafe fn unsafe_take() -> ~Task { local_ptr::unsafe_take() }
+    unsafe fn unsafe_take() -> Box<Task> { local_ptr::unsafe_take() }
     #[inline]
     unsafe fn unsafe_borrow() -> *mut Task { local_ptr::unsafe_borrow() }
     #[inline]
@@ -54,6 +55,7 @@ mod test {
     use option::{None, Option};
     use unstable::run_in_bare_thread;
     use super::*;
+    use owned::Box;
     use rt::task::Task;
 
     #[test]
@@ -61,7 +63,7 @@ mod test {
         run_in_bare_thread(proc() {
             let task = box Task::new();
             Local::put(task);
-            let task: ~Task = Local::take();
+            let task: Box<Task> = Local::take();
             cleanup_task(task);
         });
     }
@@ -71,11 +73,11 @@ mod test {
         run_in_bare_thread(proc() {
             let task = box Task::new();
             Local::put(task);
-            let task: ~Task = Local::take();
+            let task: Box<Task> = Local::take();
             cleanup_task(task);
             let task = box Task::new();
             Local::put(task);
-            let task: ~Task = Local::take();
+            let task: Box<Task> = Local::take();
             cleanup_task(task);
         });
     }
@@ -89,7 +91,7 @@ mod test {
             unsafe {
                 let _task: *mut Task = Local::unsafe_borrow();
             }
-            let task: ~Task = Local::take();
+            let task: Box<Task> = Local::take();
             cleanup_task(task);
         });
     }
@@ -104,7 +106,7 @@ mod test {
                 let _ = Local::borrow(None::<Task>);
             }
 
-            let task: ~Task = Local::take();
+            let task: Box<Task> = Local::take();
             cleanup_task(task);
         });
     }
@@ -115,15 +117,15 @@ mod test {
             let task = box Task::new();
             Local::put(task);
 
-            let t: ~Task = Local::try_take().unwrap();
-            let u: Option<~Task> = Local::try_take();
+            let t: Box<Task> = Local::try_take().unwrap();
+            let u: Option<Box<Task>> = Local::try_take();
             assert!(u.is_none());
 
             cleanup_task(t);
         });
     }
 
-    fn cleanup_task(mut t: ~Task) {
+    fn cleanup_task(mut t: Box<Task>) {
         t.destroyed = true;
     }
 
diff --git a/src/libstd/rt/local_ptr.rs b/src/libstd/rt/local_ptr.rs
index f60cfa23e81..39c0d9a5482 100644
--- a/src/libstd/rt/local_ptr.rs
+++ b/src/libstd/rt/local_ptr.rs
@@ -10,7 +10,7 @@
 
 //! Access to a single thread-local pointer.
 //!
-//! The runtime will use this for storing ~Task.
+//! The runtime will use this for storing Box<Task>.
 //!
 //! FIXME: Add runtime checks for usage of inconsistent pointer types.
 //! and for overwriting an existing pointer.
@@ -19,6 +19,7 @@
 
 use cast;
 use ops::{Drop, Deref, DerefMut};
+use owned::Box;
 use ptr::RawPtr;
 
 #[cfg(windows)]               // mingw-w32 doesn't like thread_local things
@@ -43,7 +44,7 @@ impl<T> Drop for Borrowed<T> {
             if self.val.is_null() {
                 rtabort!("Aiee, returning null borrowed object!");
             }
-            let val: ~T = cast::transmute(self.val);
+            let val: Box<T> = cast::transmute(self.val);
             put::<T>(val);
             rtassert!(exists());
         }
@@ -84,6 +85,7 @@ pub unsafe fn borrow<T>() -> Borrowed<T> {
 pub mod compiled {
     use cast;
     use option::{Option, Some, None};
+    use owned::Box;
     use ptr::RawPtr;
 
     #[cfg(test)]
@@ -154,7 +156,7 @@ pub mod compiled {
     ///
     /// Does not validate the pointer type.
     #[inline(never)] // see comments above
-    pub unsafe fn put<T>(sched: ~T) {
+    pub unsafe fn put<T>(sched: Box<T>) {
         RT_TLS_PTR = cast::transmute(sched)
     }
 
@@ -164,10 +166,10 @@ pub mod compiled {
     ///
     /// Does not validate the pointer type.
     #[inline(never)] // see comments above
-    pub unsafe fn take<T>() -> ~T {
+    pub unsafe fn take<T>() -> Box<T> {
         let ptr = RT_TLS_PTR;
         rtassert!(!ptr.is_null());
-        let ptr: ~T = cast::transmute(ptr);
+        let ptr: Box<T> = cast::transmute(ptr);
         // can't use `as`, due to type not matching with `cfg(test)`
         RT_TLS_PTR = cast::transmute(0);
         ptr
@@ -179,12 +181,12 @@ pub mod compiled {
     ///
     /// Does not validate the pointer type.
     #[inline(never)] // see comments above
-    pub unsafe fn try_take<T>() -> Option<~T> {
+    pub unsafe fn try_take<T>() -> Option<Box<T>> {
         let ptr = RT_TLS_PTR;
         if ptr.is_null() {
             None
         } else {
-            let ptr: ~T = cast::transmute(ptr);
+            let ptr: Box<T> = cast::transmute(ptr);
             // can't use `as`, due to type not matching with `cfg(test)`
             RT_TLS_PTR = cast::transmute(0);
             Some(ptr)
@@ -198,7 +200,7 @@ pub mod compiled {
     /// Does not validate the pointer type.
     /// Leaves the old pointer in TLS for speed.
     #[inline(never)] // see comments above
-    pub unsafe fn unsafe_take<T>() -> ~T {
+    pub unsafe fn unsafe_take<T>() -> Box<T> {
         cast::transmute(RT_TLS_PTR)
     }
 
@@ -234,6 +236,7 @@ pub mod compiled {
 pub mod native {
     use cast;
     use option::{Option, Some, None};
+    use owned::Box;
     use ptr;
     use ptr::RawPtr;
     use tls = rt::thread_local_storage;
@@ -259,7 +262,7 @@ pub mod native {
     ///
     /// Does not validate the pointer type.
     #[inline]
-    pub unsafe fn put<T>(sched: ~T) {
+    pub unsafe fn put<T>(sched: Box<T>) {
         let key = tls_key();
         let void_ptr: *mut u8 = cast::transmute(sched);
         tls::set(key, void_ptr);
@@ -271,13 +274,13 @@ pub mod native {
     ///
     /// Does not validate the pointer type.
     #[inline]
-    pub unsafe fn take<T>() -> ~T {
+    pub unsafe fn take<T>() -> Box<T> {
         let key = tls_key();
         let void_ptr: *mut u8 = tls::get(key);
         if void_ptr.is_null() {
             rtabort!("thread-local pointer is null. bogus!");
         }
-        let ptr: ~T = cast::transmute(void_ptr);
+        let ptr: Box<T> = cast::transmute(void_ptr);
         tls::set(key, ptr::mut_null());
         return ptr;
     }
@@ -288,14 +291,14 @@ pub mod native {
     ///
     /// Does not validate the pointer type.
     #[inline]
-    pub unsafe fn try_take<T>() -> Option<~T> {
+    pub unsafe fn try_take<T>() -> Option<Box<T>> {
         match maybe_tls_key() {
             Some(key) => {
                 let void_ptr: *mut u8 = tls::get(key);
                 if void_ptr.is_null() {
                     None
                 } else {
-                    let ptr: ~T = cast::transmute(void_ptr);
+                    let ptr: Box<T> = cast::transmute(void_ptr);
                     tls::set(key, ptr::mut_null());
                     Some(ptr)
                 }
@@ -311,13 +314,13 @@ pub mod native {
     /// Does not validate the pointer type.
     /// Leaves the old pointer in TLS for speed.
     #[inline]
-    pub unsafe fn unsafe_take<T>() -> ~T {
+    pub unsafe fn unsafe_take<T>() -> Box<T> {
         let key = tls_key();
         let void_ptr: *mut u8 = tls::get(key);
         if void_ptr.is_null() {
             rtabort!("thread-local pointer is null. bogus!");
         }
-        let ptr: ~T = cast::transmute(void_ptr);
+        let ptr: Box<T> = cast::transmute(void_ptr);
         return ptr;
     }
 
diff --git a/src/libstd/rt/mod.rs b/src/libstd/rt/mod.rs
index b407bf8897c..e79e3056838 100644
--- a/src/libstd/rt/mod.rs
+++ b/src/libstd/rt/mod.rs
@@ -57,6 +57,7 @@ Several modules in `core` are clients of `rt`:
 use any::Any;
 use kinds::Send;
 use option::Option;
+use owned::Box;
 use result::Result;
 use task::TaskOpts;
 
@@ -151,22 +152,25 @@ pub static DEFAULT_ERROR_CODE: int = 101;
 pub trait Runtime {
     // Necessary scheduling functions, used for channels and blocking I/O
     // (sometimes).
-    fn yield_now(~self, cur_task: ~Task);
-    fn maybe_yield(~self, cur_task: ~Task);
-    fn deschedule(~self, times: uint, cur_task: ~Task,
+    fn yield_now(~self, cur_task: Box<Task>);
+    fn maybe_yield(~self, cur_task: Box<Task>);
+    fn deschedule(~self, times: uint, cur_task: Box<Task>,
                   f: |BlockedTask| -> Result<(), BlockedTask>);
-    fn reawaken(~self, to_wake: ~Task);
+    fn reawaken(~self, to_wake: Box<Task>);
 
     // Miscellaneous calls which are very different depending on what context
     // you're in.
-    fn spawn_sibling(~self, cur_task: ~Task, opts: TaskOpts, f: proc():Send);
+    fn spawn_sibling(~self,
+                     cur_task: Box<Task>,
+                     opts: TaskOpts,
+                     f: proc():Send);
     fn local_io<'a>(&'a mut self) -> Option<rtio::LocalIo<'a>>;
     /// The (low, high) edges of the current stack.
     fn stack_bounds(&self) -> (uint, uint); // (lo, hi)
     fn can_block(&self) -> bool;
 
     // FIXME: This is a serious code smell and this should not exist at all.
-    fn wrap(~self) -> ~Any;
+    fn wrap(~self) -> Box<Any>;
 }
 
 /// One-time runtime initialization.
diff --git a/src/libstd/rt/rtio.rs b/src/libstd/rt/rtio.rs
index fc8c79549af..fe9f4932a2a 100644
--- a/src/libstd/rt/rtio.rs
+++ b/src/libstd/rt/rtio.rs
@@ -18,6 +18,7 @@ use libc;
 use kinds::Send;
 use ops::Drop;
 use option::{Option, Some, None};
+use owned::Box;
 use path::Path;
 use result::Err;
 use rt::local::Local;
@@ -40,9 +41,10 @@ pub trait Callback {
 pub trait EventLoop {
     fn run(&mut self);
     fn callback(&mut self, arg: proc():Send);
-    fn pausable_idle_callback(&mut self,
-                              ~Callback:Send) -> ~PausableIdleCallback:Send;
-    fn remote_callback(&mut self, ~Callback:Send) -> ~RemoteCallback:Send;
+    fn pausable_idle_callback(&mut self, Box<Callback:Send>)
+                              -> Box<PausableIdleCallback:Send>;
+    fn remote_callback(&mut self, Box<Callback:Send>)
+                       -> Box<RemoteCallback:Send>;
 
     /// The asynchronous I/O services. Not all event loops may provide one.
     fn io<'a>(&'a mut self) -> Option<&'a mut IoFactory>;
@@ -114,7 +116,7 @@ impl<'a> LocalIo<'a> {
         //
         // In order to get around this, we just transmute a copy out of the task
         // in order to have what is likely a static lifetime (bad).
-        let mut t: ~Task = Local::take();
+        let mut t: Box<Task> = Local::take();
         let ret = t.local_io().map(|t| {
             unsafe { cast::transmute_copy(&t) }
         });
@@ -149,21 +151,23 @@ impl<'a> LocalIo<'a> {
 pub trait IoFactory {
     // networking
     fn tcp_connect(&mut self, addr: SocketAddr,
-                   timeout: Option<u64>) -> IoResult<~RtioTcpStream:Send>;
-    fn tcp_bind(&mut self, addr: SocketAddr) -> IoResult<~RtioTcpListener:Send>;
-    fn udp_bind(&mut self, addr: SocketAddr) -> IoResult<~RtioUdpSocket:Send>;
+                   timeout: Option<u64>) -> IoResult<Box<RtioTcpStream:Send>>;
+    fn tcp_bind(&mut self, addr: SocketAddr)
+                -> IoResult<Box<RtioTcpListener:Send>>;
+    fn udp_bind(&mut self, addr: SocketAddr)
+                -> IoResult<Box<RtioUdpSocket:Send>>;
     fn unix_bind(&mut self, path: &CString)
-        -> IoResult<~RtioUnixListener:Send>;
+                 -> IoResult<Box<RtioUnixListener:Send>>;
     fn unix_connect(&mut self, path: &CString,
-                    timeout: Option<u64>) -> IoResult<~RtioPipe:Send>;
+                    timeout: Option<u64>) -> IoResult<Box<RtioPipe:Send>>;
     fn get_host_addresses(&mut self, host: Option<&str>, servname: Option<&str>,
                           hint: Option<ai::Hint>) -> IoResult<~[ai::Info]>;
 
     // filesystem operations
     fn fs_from_raw_fd(&mut self, fd: c_int, close: CloseBehavior)
-        -> ~RtioFileStream:Send;
+                      -> Box<RtioFileStream:Send>;
     fn fs_open(&mut self, path: &CString, fm: FileMode, fa: FileAccess)
-        -> IoResult<~RtioFileStream:Send>;
+               -> IoResult<Box<RtioFileStream:Send>>;
     fn fs_unlink(&mut self, path: &CString) -> IoResult<()>;
     fn fs_stat(&mut self, path: &CString) -> IoResult<FileStat>;
     fn fs_mkdir(&mut self, path: &CString,
@@ -184,23 +188,24 @@ pub trait IoFactory {
         IoResult<()>;
 
     // misc
-    fn timer_init(&mut self) -> IoResult<~RtioTimer:Send>;
+    fn timer_init(&mut self) -> IoResult<Box<RtioTimer:Send>>;
     fn spawn(&mut self, config: ProcessConfig)
-            -> IoResult<(~RtioProcess:Send, ~[Option<~RtioPipe:Send>])>;
+            -> IoResult<(Box<RtioProcess:Send>,
+                         ~[Option<Box<RtioPipe:Send>>])>;
     fn kill(&mut self, pid: libc::pid_t, signal: int) -> IoResult<()>;
-    fn pipe_open(&mut self, fd: c_int) -> IoResult<~RtioPipe:Send>;
+    fn pipe_open(&mut self, fd: c_int) -> IoResult<Box<RtioPipe:Send>>;
     fn tty_open(&mut self, fd: c_int, readable: bool)
-            -> IoResult<~RtioTTY:Send>;
+            -> IoResult<Box<RtioTTY:Send>>;
     fn signal(&mut self, signal: Signum, channel: Sender<Signum>)
-        -> IoResult<~RtioSignal:Send>;
+        -> IoResult<Box<RtioSignal:Send>>;
 }
 
 pub trait RtioTcpListener : RtioSocket {
-    fn listen(~self) -> IoResult<~RtioTcpAcceptor:Send>;
+    fn listen(~self) -> IoResult<Box<RtioTcpAcceptor:Send>>;
 }
 
 pub trait RtioTcpAcceptor : RtioSocket {
-    fn accept(&mut self) -> IoResult<~RtioTcpStream:Send>;
+    fn accept(&mut self) -> IoResult<Box<RtioTcpStream:Send>>;
     fn accept_simultaneously(&mut self) -> IoResult<()>;
     fn dont_accept_simultaneously(&mut self) -> IoResult<()>;
     fn set_timeout(&mut self, timeout: Option<u64>);
@@ -214,7 +219,7 @@ pub trait RtioTcpStream : RtioSocket {
     fn nodelay(&mut self) -> IoResult<()>;
     fn keepalive(&mut self, delay_in_seconds: uint) -> IoResult<()>;
     fn letdie(&mut self) -> IoResult<()>;
-    fn clone(&self) -> ~RtioTcpStream:Send;
+    fn clone(&self) -> Box<RtioTcpStream:Send>;
     fn close_write(&mut self) -> IoResult<()>;
 }
 
@@ -238,7 +243,7 @@ pub trait RtioUdpSocket : RtioSocket {
     fn hear_broadcasts(&mut self) -> IoResult<()>;
     fn ignore_broadcasts(&mut self) -> IoResult<()>;
 
-    fn clone(&self) -> ~RtioUdpSocket:Send;
+    fn clone(&self) -> Box<RtioUdpSocket:Send>;
 }
 
 pub trait RtioTimer {
@@ -268,15 +273,15 @@ pub trait RtioProcess {
 pub trait RtioPipe {
     fn read(&mut self, buf: &mut [u8]) -> IoResult<uint>;
     fn write(&mut self, buf: &[u8]) -> IoResult<()>;
-    fn clone(&self) -> ~RtioPipe:Send;
+    fn clone(&self) -> Box<RtioPipe:Send>;
 }
 
 pub trait RtioUnixListener {
-    fn listen(~self) -> IoResult<~RtioUnixAcceptor:Send>;
+    fn listen(~self) -> IoResult<Box<RtioUnixAcceptor:Send>>;
 }
 
 pub trait RtioUnixAcceptor {
-    fn accept(&mut self) -> IoResult<~RtioPipe:Send>;
+    fn accept(&mut self) -> IoResult<Box<RtioPipe:Send>>;
     fn set_timeout(&mut self, timeout: Option<u64>);
 }
 
diff --git a/src/libstd/rt/stack.rs b/src/libstd/rt/stack.rs
index 963ff000c4a..b9bcd1de8fc 100644
--- a/src/libstd/rt/stack.rs
+++ b/src/libstd/rt/stack.rs
@@ -37,6 +37,7 @@ pub static RED_ZONE: uint = 20 * 1024;
 #[cfg(not(test))] // in testing, use the original libstd's version
 pub extern "C" fn rust_stack_exhausted() {
     use option::{Option, None, Some};
+    use owned::Box;
     use rt::local::Local;
     use rt::task::Task;
     use str::Str;
@@ -85,7 +86,7 @@ pub extern "C" fn rust_stack_exhausted() {
         //  #9854 - unwinding on windows through __morestack has never worked
         //  #2361 - possible implementation of not using landing pads
 
-        let task: Option<~Task> = Local::try_take();
+        let task: Option<Box<Task>> = Local::try_take();
         let name = match task {
             Some(ref task) => {
                 task.name.as_ref().map(|n| n.as_slice())
diff --git a/src/libstd/rt/task.rs b/src/libstd/rt/task.rs
index ae5786604c7..5b29de5a8c1 100644
--- a/src/libstd/rt/task.rs
+++ b/src/libstd/rt/task.rs
@@ -24,6 +24,7 @@ use kinds::Send;
 use local_data;
 use ops::Drop;
 use option::{Option, Some, None};
+use owned::Box;
 use prelude::drop;
 use result::{Result, Ok, Err};
 use rt::Runtime;
@@ -51,19 +52,20 @@ pub struct Task {
     pub destroyed: bool,
     pub name: Option<SendStr>,
 
-    pub stdout: Option<~Writer:Send>,
-    pub stderr: Option<~Writer:Send>,
+    pub stdout: Option<Box<Writer:Send>>,
+    pub stderr: Option<Box<Writer:Send>>,
 
-    imp: Option<~Runtime:Send>,
+    imp: Option<Box<Runtime:Send>>,
 }
 
 pub struct GarbageCollector;
 pub struct LocalStorage(pub Option<local_data::Map>);
 
-/// A handle to a blocked task. Usually this means having the ~Task pointer by
-/// ownership, but if the task is killable, a killer can steal it at any time.
+/// A handle to a blocked task. Usually this means having the Box<Task>
+/// pointer by ownership, but if the task is killable, a killer can steal it
+/// at any time.
 pub enum BlockedTask {
-    Owned(~Task),
+    Owned(Box<Task>),
     Shared(UnsafeArc<AtomicUint>),
 }
 
@@ -109,12 +111,12 @@ impl Task {
     /// This function is *not* meant to be abused as a "try/catch" block. This
     /// is meant to be used at the absolute boundaries of a task's lifetime, and
     /// only for that purpose.
-    pub fn run(~self, mut f: ||) -> ~Task {
+    pub fn run(~self, mut f: ||) -> Box<Task> {
         // Need to put ourselves into TLS, but also need access to the unwinder.
         // Unsafely get a handle to the task so we can continue to use it after
         // putting it in tls (so we can invoke the unwinder).
         let handle: *mut Task = unsafe {
-            *cast::transmute::<&~Task, &*mut Task>(&self)
+            *cast::transmute::<&Box<Task>, &*mut Task>(&self)
         };
         Local::put(self);
 
@@ -187,7 +189,7 @@ impl Task {
             let me: *mut Task = Local::unsafe_borrow();
             (*me).death.collect_failure((*me).unwinder.result());
         }
-        let mut me: ~Task = Local::take();
+        let mut me: Box<Task> = Local::take();
         me.destroyed = true;
         return me;
     }
@@ -195,7 +197,7 @@ impl Task {
     /// Inserts a runtime object into this task, transferring ownership to the
     /// task. It is illegal to replace a previous runtime object in this task
     /// with this argument.
-    pub fn put_runtime(&mut self, ops: ~Runtime:Send) {
+    pub fn put_runtime(&mut self, ops: Box<Runtime:Send>) {
         assert!(self.imp.is_none());
         self.imp = Some(ops);
     }
@@ -207,12 +209,12 @@ impl Task {
     ///
     /// It is recommended to only use this method when *absolutely necessary*.
     /// This function may not be available in the future.
-    pub fn maybe_take_runtime<T: 'static>(&mut self) -> Option<~T> {
+    pub fn maybe_take_runtime<T: 'static>(&mut self) -> Option<Box<T>> {
         // This is a terrible, terrible function. The general idea here is to
-        // take the runtime, cast it to ~Any, check if it has the right type,
-        // and then re-cast it back if necessary. The method of doing this is
-        // pretty sketchy and involves shuffling vtables of trait objects
-        // around, but it gets the job done.
+        // take the runtime, cast it to Box<Any>, check if it has the right
+        // type, and then re-cast it back if necessary. The method of doing
+        // this is pretty sketchy and involves shuffling vtables of trait
+        // objects around, but it gets the job done.
         //
         // FIXME: This function is a serious code smell and should be avoided at
         //      all costs. I have yet to think of a method to avoid this
@@ -225,7 +227,8 @@ impl Task {
                 Ok(t) => Some(t),
                 Err(t) => {
                     let (_, obj): (uint, uint) = cast::transmute(t);
-                    let obj: ~Runtime:Send = cast::transmute((vtable, obj));
+                    let obj: Box<Runtime:Send> =
+                        cast::transmute((vtable, obj));
                     self.put_runtime(obj);
                     None
                 }
@@ -308,7 +311,7 @@ impl Iterator<BlockedTask> for BlockedTasks {
 
 impl BlockedTask {
     /// Returns Some if the task was successfully woken; None if already killed.
-    pub fn wake(self) -> Option<~Task> {
+    pub fn wake(self) -> Option<Box<Task>> {
         match self {
             Owned(task) => Some(task),
             Shared(arc) => unsafe {
@@ -326,7 +329,7 @@ impl BlockedTask {
     #[cfg(test)]      pub fn trash(self) { assert!(self.wake().is_none()); }
 
     /// Create a blocked task, unless the task was already killed.
-    pub fn block(task: ~Task) -> BlockedTask {
+    pub fn block(task: Box<Task>) -> BlockedTask {
         Owned(task)
     }
 
@@ -367,7 +370,7 @@ impl BlockedTask {
         if blocked_task_ptr & 0x1 == 0 {
             Owned(cast::transmute(blocked_task_ptr))
         } else {
-            let ptr: ~UnsafeArc<AtomicUint> =
+            let ptr: Box<UnsafeArc<AtomicUint>> =
                 cast::transmute(blocked_task_ptr & !1);
             Shared(*ptr)
         }
diff --git a/src/libstd/rt/thread.rs b/src/libstd/rt/thread.rs
index a836958279b..bc9a0b3460a 100644
--- a/src/libstd/rt/thread.rs
+++ b/src/libstd/rt/thread.rs
@@ -22,6 +22,7 @@ use kinds::Send;
 use libc;
 use ops::Drop;
 use option::{Option, Some, None};
+use owned::Box;
 use uint;
 
 type StartFn = extern "C" fn(*libc::c_void) -> imp::rust_thread_return;
@@ -31,7 +32,7 @@ type StartFn = extern "C" fn(*libc::c_void) -> imp::rust_thread_return;
 pub struct Thread<T> {
     native: imp::rust_thread,
     joined: bool,
-    packet: ~Option<T>,
+    packet: Box<Option<T>>,
 }
 
 static DEFAULT_STACK_SIZE: uint = 1024 * 1024;
@@ -45,7 +46,7 @@ extern fn thread_start(main: *libc::c_void) -> imp::rust_thread_return {
     use rt::stack;
     unsafe {
         stack::record_stack_bounds(0, uint::MAX);
-        let f: ~proc() = cast::transmute(main);
+        let f: Box<proc()> = cast::transmute(main);
         (*f)();
         cast::transmute(0 as imp::rust_thread_return)
     }
@@ -78,11 +79,11 @@ impl Thread<()> {
     pub fn start_stack<T: Send>(stack: uint, main: proc():Send -> T) -> Thread<T> {
 
         // We need the address of the packet to fill in to be stable so when
-        // `main` fills it in it's still valid, so allocate an extra ~ box to do
+        // `main` fills it in it's still valid, so allocate an extra box to do
         // so.
         let packet = box None;
         let packet2: *mut Option<T> = unsafe {
-            *cast::transmute::<&~Option<T>, **mut Option<T>>(&packet)
+            *cast::transmute::<&Box<Option<T>>, **mut Option<T>>(&packet)
         };
         let main = proc() unsafe { *packet2 = Some(main()); };
         let native = unsafe { imp::create(stack, box main) };
@@ -152,13 +153,14 @@ mod imp {
     use libc::types::os::arch::extra::{LPSECURITY_ATTRIBUTES, SIZE_T, BOOL,
                                        LPVOID, DWORD, LPDWORD, HANDLE};
     use os;
+    use owned::Box;
     use ptr;
     use rt::stack::RED_ZONE;
 
     pub type rust_thread = HANDLE;
     pub type rust_thread_return = DWORD;
 
-    pub unsafe fn create(stack: uint, p: ~proc():Send) -> rust_thread {
+    pub unsafe fn create(stack: uint, p: Box<proc():Send>) -> rust_thread {
         let arg: *mut libc::c_void = cast::transmute(p);
         // FIXME On UNIX, we guard against stack sizes that are too small but
         // that's because pthreads enforces that stacks are at least
@@ -175,7 +177,7 @@ mod imp {
 
         if ret as uint == 0 {
             // be sure to not leak the closure
-            let _p: ~proc():Send = cast::transmute(arg);
+            let _p: Box<proc():Send> = cast::transmute(arg);
             fail!("failed to spawn native thread: {}", os::last_os_error());
         }
         return ret;
@@ -218,13 +220,14 @@ mod imp {
     use libc;
     use mem;
     use os;
+    use owned::Box;
     use ptr;
     use rt::stack::RED_ZONE;
 
     pub type rust_thread = libc::pthread_t;
     pub type rust_thread_return = *u8;
 
-    pub unsafe fn create(stack: uint, p: ~proc():Send) -> rust_thread {
+    pub unsafe fn create(stack: uint, p: Box<proc():Send>) -> rust_thread {
         let mut native: libc::pthread_t = mem::uninit();
         let mut attr: libc::pthread_attr_t = mem::uninit();
         assert_eq!(pthread_attr_init(&mut attr), 0);
@@ -257,7 +260,7 @@ mod imp {
 
         if ret != 0 {
             // be sure to not leak the closure
-            let _p: ~proc():Send = cast::transmute(arg);
+            let _p: Box<proc():Send> = cast::transmute(arg);
             fail!("failed to spawn native thread: {}", os::last_os_error());
         }
         native
diff --git a/src/libstd/rt/thread_local_storage.rs b/src/libstd/rt/thread_local_storage.rs
index fceff80e792..77062068636 100644
--- a/src/libstd/rt/thread_local_storage.rs
+++ b/src/libstd/rt/thread_local_storage.rs
@@ -10,6 +10,8 @@
 
 #![allow(dead_code)]
 
+#[cfg(test)]
+use owned::Box;
 #[cfg(unix)]
 use libc::c_int;
 #[cfg(unix)]
@@ -99,11 +101,11 @@ fn tls_smoke_test() {
         let value = box 20;
         create(&mut key);
         set(key, transmute(value));
-        let value: ~int = transmute(get(key));
+        let value: Box<int> = transmute(get(key));
         assert_eq!(value, box 20);
         let value = box 30;
         set(key, transmute(value));
-        let value: ~int = transmute(get(key));
+        let value: Box<int> = transmute(get(key));
         assert_eq!(value, box 30);
     }
 }
diff --git a/src/libstd/rt/unwind.rs b/src/libstd/rt/unwind.rs
index 98623c35b78..3ba97f381ab 100644
--- a/src/libstd/rt/unwind.rs
+++ b/src/libstd/rt/unwind.rs
@@ -64,6 +64,7 @@ use fmt;
 use kinds::Send;
 use mem;
 use option::{Some, None, Option};
+use owned::Box;
 use prelude::drop;
 use ptr::RawPtr;
 use result::{Err, Ok};
@@ -78,7 +79,7 @@ use uw = rt::libunwind;
 
 pub struct Unwinder {
     unwinding: bool,
-    cause: Option<~Any:Send>
+    cause: Option<Box<Any:Send>>
 }
 
 impl Unwinder {
@@ -128,7 +129,7 @@ impl Unwinder {
         }
     }
 
-    pub fn begin_unwind(&mut self, cause: ~Any:Send) -> ! {
+    pub fn begin_unwind(&mut self, cause: Box<Any:Send>) -> ! {
         rtdebug!("begin_unwind()");
 
         self.unwinding = true;
@@ -154,7 +155,8 @@ impl Unwinder {
                                             exception: *uw::_Unwind_Exception) {
                 rtdebug!("exception_cleanup()");
                 unsafe {
-                    let _: ~uw::_Unwind_Exception = cast::transmute(exception);
+                    let _: Box<uw::_Unwind_Exception> =
+                        cast::transmute(exception);
                 }
             }
         }
@@ -374,14 +376,16 @@ pub fn begin_unwind<M: Any + Send>(msg: M, file: &'static str, line: uint) -> !
 /// Do this split took the LLVM IR line counts of `fn main() { fail!()
 /// }` from ~1900/3700 (-O/no opts) to 180/590.
 #[inline(never)] #[cold] // this is the slow path, please never inline this
-fn begin_unwind_inner(msg: ~Any:Send, file: &'static str, line: uint) -> ! {
+fn begin_unwind_inner(msg: Box<Any:Send>,
+                      file: &'static str,
+                      line: uint) -> ! {
     let mut task;
     {
         let msg_s = match msg.as_ref::<&'static str>() {
             Some(s) => *s,
             None => match msg.as_ref::<~str>() {
                 Some(s) => s.as_slice(),
-                None => "~Any",
+                None => "Box<Any>",
             }
         };
 
@@ -392,7 +396,7 @@ fn begin_unwind_inner(msg: ~Any:Send, file: &'static str, line: uint) -> ! {
         // order to get some better diagnostics, we print on failure and
         // immediately abort the whole process if there is no local task
         // available.
-        let opt_task: Option<~Task> = Local::try_take();
+        let opt_task: Option<Box<Task>> = Local::try_take();
         task = match opt_task {
             Some(t) => t,
             None => {
diff --git a/src/libstd/slice.rs b/src/libstd/slice.rs
index b8b39928ecf..6c8a329446d 100644
--- a/src/libstd/slice.rs
+++ b/src/libstd/slice.rs
@@ -2352,10 +2352,11 @@ impl<A> FromIterator<A> for ~[A] {
 #[cfg(test)]
 mod tests {
     use prelude::*;
-    use mem;
-    use slice::*;
     use cmp::*;
+    use mem;
+    use owned::Box;
     use rand::{Rng, task_rng};
+    use slice::*;
 
     fn square(n: uint) -> uint { n * n }
 
@@ -2738,8 +2739,8 @@ mod tests {
         let mut v2 = vec![box 1, box 2, box 3, box 3];
         v2.dedup();
         /*
-         * If the ~pointers were leaked or otherwise misused, valgrind and/or
-         * rustrt should raise errors.
+         * If the boxed pointers were leaked or otherwise misused, valgrind
+         * and/or rustrt should raise errors.
          */
     }
 
@@ -3117,7 +3118,7 @@ mod tests {
 
         struct S {
             f: Cell<int>,
-            boxes: (~int, Rc<int>)
+            boxes: (Box<int>, Rc<int>)
         }
 
         impl Clone for S {
@@ -3566,13 +3567,7 @@ mod tests {
         }
         assert_eq!(cnt, 11);
 
-        let xs = vec![Foo, Foo, Foo];
-        assert_eq!(format!("{:?}", xs.slice(0, 2).to_owned()),
-                   "~[slice::tests::Foo, slice::tests::Foo]".to_owned());
-
         let xs: [Foo, ..3] = [Foo, Foo, Foo];
-        assert_eq!(format!("{:?}", xs.slice(0, 2).to_owned()),
-                   "~[slice::tests::Foo, slice::tests::Foo]".to_owned());
         cnt = 0;
         for f in xs.iter() {
             assert!(*f == Foo);
diff --git a/src/libstd/str.rs b/src/libstd/str.rs
index d7696dc53c0..54ddf60ed7d 100644
--- a/src/libstd/str.rs
+++ b/src/libstd/str.rs
@@ -20,9 +20,9 @@ Rust. Each string must also be decorated with its ownership. This means that
 there are two common kinds of strings in Rust:
 
 * `~str` - This is an owned string. This type obeys all of the normal semantics
-           of the `~T` types, meaning that it has one, and only one, owner. This
-           type cannot be implicitly copied, and is moved out of when passed to
-           other functions.
+           of the `Box<T>` types, meaning that it has one, and only one,
+           owner. This type cannot be implicitly copied, and is moved out of
+           when passed to other functions.
 
 * `&str` - This is the borrowed string type. This type of string can only be
            created from the other kind of string. As the name "borrowed"
diff --git a/src/libstd/sync/arc.rs b/src/libstd/sync/arc.rs
index 0cf975a4c1c..d277c514e44 100644
--- a/src/libstd/sync/arc.rs
+++ b/src/libstd/sync/arc.rs
@@ -26,6 +26,7 @@ use clone::Clone;
 use iter::Iterator;
 use kinds::Send;
 use ops::Drop;
+use owned::Box;
 use ptr::RawPtr;
 use sync::atomics::{fence, AtomicUint, Relaxed, Acquire, Release};
 use ty::Unsafe;
@@ -157,7 +158,7 @@ impl<T> Drop for UnsafeArc<T>{
                 //  happened before), and an "acquire" operation before deleting the object.
                 // [1]: (www.boost.org/doc/libs/1_55_0/doc/html/atomic/usage_examples.html)
                 fence(Acquire);
-                let _: ~ArcData<T> = cast::transmute(self.data);
+                let _: Box<ArcData<T>> = cast::transmute(self.data);
             }
         }
     }
diff --git a/src/libstd/sync/atomics.rs b/src/libstd/sync/atomics.rs
index a3c1c33f77c..2fba59c3233 100644
--- a/src/libstd/sync/atomics.rs
+++ b/src/libstd/sync/atomics.rs
@@ -88,7 +88,7 @@
 //!         }
 //!     });
 //!
-//!     shared_big_object.swap(~BigObject, SeqCst);
+//!     shared_big_object.swap(box BigObject, SeqCst);
 //! }
 //! ```
 //!
@@ -112,6 +112,7 @@ use cast;
 use std::kinds::marker;
 use option::{Option,Some,None};
 use ops::Drop;
+use owned::Box;
 use ty::Unsafe;
 
 /// An atomic boolean type.
@@ -663,7 +664,7 @@ impl<T> AtomicPtr<T> {
 
 impl<T> AtomicOption<T> {
     /// Create a new `AtomicOption`
-    pub fn new(p: ~T) -> AtomicOption<T> {
+    pub fn new(p: Box<T>) -> AtomicOption<T> {
         unsafe { AtomicOption { p: Unsafe::new(cast::transmute(p)) } }
     }
 
@@ -672,7 +673,7 @@ impl<T> AtomicOption<T> {
 
     /// Store a value, returning the old value
     #[inline]
-    pub fn swap(&self, val: ~T, order: Ordering) -> Option<~T> {
+    pub fn swap(&self, val: Box<T>, order: Ordering) -> Option<Box<T>> {
         unsafe {
             let val = cast::transmute(val);
 
@@ -687,7 +688,7 @@ impl<T> AtomicOption<T> {
 
     /// Remove the value, leaving the `AtomicOption` empty.
     #[inline]
-    pub fn take(&self, order: Ordering) -> Option<~T> {
+    pub fn take(&self, order: Ordering) -> Option<Box<T>> {
         unsafe { self.swap(cast::transmute(0), order) }
     }
 
@@ -697,7 +698,7 @@ impl<T> AtomicOption<T> {
     /// the option was already `Some`, returns `Some` of the rejected
     /// value.
     #[inline]
-    pub fn fill(&self, val: ~T, order: Ordering) -> Option<~T> {
+    pub fn fill(&self, val: Box<T>, order: Ordering) -> Option<Box<T>> {
         unsafe {
             let val = cast::transmute(val);
             let expected = cast::transmute(0);
diff --git a/src/libstd/sync/deque.rs b/src/libstd/sync/deque.rs
index 22ed66b708b..d06062f02ac 100644
--- a/src/libstd/sync/deque.rs
+++ b/src/libstd/sync/deque.rs
@@ -56,6 +56,7 @@ use libc;
 use mem;
 use ops::Drop;
 use option::{Option, Some, None};
+use owned::Box;
 use ptr;
 use ptr::RawPtr;
 use sync::arc::UnsafeArc;
@@ -117,7 +118,7 @@ pub enum Stolen<T> {
 /// will only use this structure when allocating a new buffer or deallocating a
 /// previous one.
 pub struct BufferPool<T> {
-    pool: Exclusive<Vec<~Buffer<T>>>,
+    pool: Exclusive<Vec<Box<Buffer<T>>>>,
 }
 
 /// An internal buffer used by the chase-lev deque. This structure is actually
@@ -154,7 +155,7 @@ impl<T: Send> BufferPool<T> {
         (Worker { deque: a }, Stealer { deque: b })
     }
 
-    fn alloc(&mut self, bits: int) -> ~Buffer<T> {
+    fn alloc(&mut self, bits: int) -> Box<Buffer<T>> {
         unsafe {
             self.pool.with(|pool| {
                 match pool.iter().position(|x| x.size() >= (1 << bits)) {
@@ -165,7 +166,7 @@ impl<T: Send> BufferPool<T> {
         }
     }
 
-    fn free(&mut self, buf: ~Buffer<T>) {
+    fn free(&mut self, buf: Box<Buffer<T>>) {
         unsafe {
             let mut buf = Some(buf);
             self.pool.with(|pool| {
@@ -400,6 +401,7 @@ mod tests {
     use super::{Data, BufferPool, Abort, Empty, Worker, Stealer};
 
     use cast;
+    use owned::Box;
     use rt::thread::Thread;
     use rand;
     use rand::Rng;
@@ -471,7 +473,7 @@ mod tests {
         t.join();
     }
 
-    fn stampede(mut w: Worker<~int>, s: Stealer<~int>,
+    fn stampede(mut w: Worker<Box<int>>, s: Stealer<Box<int>>,
                 nthreads: int, amt: uint) {
         for _ in range(0, amt) {
             w.push(box 20);
@@ -486,7 +488,7 @@ mod tests {
                     let mut s = s;
                     while (*unsafe_remaining).load(SeqCst) > 0 {
                         match s.steal() {
-                            Data(~20) => {
+                            Data(box 20) => {
                                 (*unsafe_remaining).fetch_sub(1, SeqCst);
                             }
                             Data(..) => fail!(),
@@ -499,7 +501,7 @@ mod tests {
 
         while remaining.load(SeqCst) > 0 {
             match w.pop() {
-                Some(~20) => { remaining.fetch_sub(1, SeqCst); }
+                Some(box 20) => { remaining.fetch_sub(1, SeqCst); }
                 Some(..) => fail!(),
                 None => {}
             }
@@ -512,7 +514,7 @@ mod tests {
 
     #[test]
     fn run_stampede() {
-        let mut pool = BufferPool::<~int>::new();
+        let mut pool = BufferPool::<Box<int>>::new();
         let (w, s) = pool.deque();
         stampede(w, s, 8, 10000);
     }
@@ -520,7 +522,7 @@ mod tests {
     #[test]
     fn many_stampede() {
         static AMT: uint = 4;
-        let mut pool = BufferPool::<~int>::new();
+        let mut pool = BufferPool::<Box<int>>::new();
         let threads = range(0, AMT).map(|_| {
             let (w, s) = pool.deque();
             Thread::start(proc() {
@@ -605,7 +607,8 @@ mod tests {
             let s = s.clone();
             let unique_box = box AtomicUint::new(0);
             let thread_box = unsafe {
-                *cast::transmute::<&~AtomicUint,**mut AtomicUint>(&unique_box)
+                *cast::transmute::<&Box<AtomicUint>,
+                                   **mut AtomicUint>(&unique_box)
             };
             (Thread::start(proc() {
                 unsafe {
diff --git a/src/libstd/sync/mpsc_queue.rs b/src/libstd/sync/mpsc_queue.rs
index 315e412446d..e05959e2591 100644
--- a/src/libstd/sync/mpsc_queue.rs
+++ b/src/libstd/sync/mpsc_queue.rs
@@ -42,6 +42,7 @@ use cast;
 use kinds::Send;
 use ops::Drop;
 use option::{Option, None, Some};
+use owned::Box;
 use ptr::RawPtr;
 use sync::atomics::{AtomicPtr, Release, Acquire, AcqRel, Relaxed};
 
@@ -120,7 +121,7 @@ impl<T: Send> Queue<T> {
                 assert!((*tail).value.is_none());
                 assert!((*next).value.is_some());
                 let ret = (*next).value.take_unwrap();
-                let _: ~Node<T> = cast::transmute(tail);
+                let _: Box<Node<T>> = cast::transmute(tail);
                 return Data(ret);
             }
 
@@ -145,7 +146,7 @@ impl<T: Send> Drop for Queue<T> {
             let mut cur = self.tail;
             while !cur.is_null() {
                 let next = (*cur).next.load(Relaxed);
-                let _: ~Node<T> = cast::transmute(cur);
+                let _: Box<Node<T>> = cast::transmute(cur);
                 cur = next;
             }
         }
diff --git a/src/libstd/sync/spsc_queue.rs b/src/libstd/sync/spsc_queue.rs
index f155bdca446..7854a0e168e 100644
--- a/src/libstd/sync/spsc_queue.rs
+++ b/src/libstd/sync/spsc_queue.rs
@@ -37,6 +37,7 @@ use cast;
 use kinds::Send;
 use ops::Drop;
 use option::{Some, None, Option};
+use owned::Box;
 use ptr::RawPtr;
 use sync::atomics::{AtomicPtr, Relaxed, AtomicUint, Acquire, Release};
 
@@ -187,7 +188,7 @@ impl<T: Send> Queue<T> {
                     (*self.tail_prev.load(Relaxed)).next.store(next, Relaxed);
                     // We have successfully erased all references to 'tail', so
                     // now we can safely drop it.
-                    let _: ~Node<T> = cast::transmute(tail);
+                    let _: Box<Node<T>> = cast::transmute(tail);
                 }
             }
             return ret;
@@ -215,7 +216,7 @@ impl<T: Send> Drop for Queue<T> {
             let mut cur = self.first;
             while !cur.is_null() {
                 let next = (*cur).next.load(Relaxed);
-                let _n: ~Node<T> = cast::transmute(cur);
+                let _n: Box<Node<T>> = cast::transmute(cur);
                 cur = next;
             }
         }
diff --git a/src/libstd/task.rs b/src/libstd/task.rs
index e9b01063f94..7c5e984ad36 100644
--- a/src/libstd/task.rs
+++ b/src/libstd/task.rs
@@ -41,6 +41,7 @@ use comm::{Sender, Receiver, channel};
 use io::Writer;
 use kinds::{Send, marker};
 use option::{None, Some, Option};
+use owned::Box;
 use result::{Result, Ok, Err};
 use rt::local::Local;
 use rt::task::Task;
@@ -56,7 +57,7 @@ use str::{Str, SendStr, IntoMaybeOwned};
 ///
 /// If you wish for this result's delivery to block until all
 /// children tasks complete, recommend using a result future.
-pub type TaskResult = Result<(), ~Any:Send>;
+pub type TaskResult = Result<(), Box<Any:Send>>;
 
 /// Task configuration options
 pub struct TaskOpts {
@@ -67,9 +68,9 @@ pub struct TaskOpts {
     /// The size of the stack for the spawned task
     pub stack_size: Option<uint>,
     /// Task-local stdout
-    pub stdout: Option<~Writer:Send>,
+    pub stdout: Option<Box<Writer:Send>>,
     /// Task-local stderr
-    pub stderr: Option<~Writer:Send>,
+    pub stderr: Option<Box<Writer:Send>>,
 }
 
 /**
@@ -173,7 +174,7 @@ impl TaskBuilder {
             Some(gen) => gen(f),
             None => f
         };
-        let t: ~Task = Local::take();
+        let t: Box<Task> = Local::take();
         t.spawn_sibling(self.opts, f);
     }
 
@@ -190,7 +191,8 @@ impl TaskBuilder {
      * # Failure
      * Fails if a future_result was already set for this task.
      */
-    pub fn try<T:Send>(mut self, f: proc():Send -> T) -> Result<T, ~Any:Send> {
+    pub fn try<T:Send>(mut self, f: proc():Send -> T)
+               -> Result<T, Box<Any:Send>> {
         let (tx, rx) = channel();
 
         let result = self.future_result();
@@ -240,7 +242,7 @@ pub fn spawn(f: proc():Send) {
 /// the function or an error if the task failed
 ///
 /// This is equivalent to TaskBuilder::new().try
-pub fn try<T:Send>(f: proc():Send -> T) -> Result<T, ~Any:Send> {
+pub fn try<T:Send>(f: proc():Send -> T) -> Result<T, Box<Any:Send>> {
     TaskBuilder::new().try(f)
 }
 
@@ -264,7 +266,7 @@ pub fn deschedule() {
     use rt::local::Local;
 
     // FIXME(#7544): Optimize this, since we know we won't block.
-    let task: ~Task = Local::take();
+    let task: Box<Task> = Local::take();
     task.yield_now();
 }
 
@@ -507,10 +509,10 @@ fn test_try_fail_message_owned_str() {
 #[test]
 fn test_try_fail_message_any() {
     match try(proc() {
-        fail!(box 413u16 as ~Any:Send);
+        fail!(box 413u16 as Box<Any:Send>);
     }) {
         Err(e) => {
-            type T = ~Any:Send;
+            type T = Box<Any:Send>;
             assert!(e.is::<T>());
             let any = e.move::<T>().unwrap();
             assert!(any.is::<u16>());
diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs
index e264615578e..f0f126bcf16 100644
--- a/src/libstd/vec.rs
+++ b/src/libstd/vec.rs
@@ -971,9 +971,9 @@ impl<T> Vec<T> {
     /// # Example
     ///
     /// ```rust
-    /// let mut vec = vec!(~1);
-    /// vec.push_all_move(vec!(~2, ~3, ~4));
-    /// assert_eq!(vec, vec!(~1, ~2, ~3, ~4));
+    /// let mut vec = vec!(box 1);
+    /// vec.push_all_move(vec!(box 2, box 3, box 4));
+    /// assert_eq!(vec, vec!(box 1, box 2, box 3, box 4));
     /// ```
     pub fn push_all_move(&mut self, other: Vec<T>) {
         self.extend(other.move_iter());
diff --git a/src/libsync/mutex.rs b/src/libsync/mutex.rs
index e41484c46bd..54c3a9c77f8 100644
--- a/src/libsync/mutex.rs
+++ b/src/libsync/mutex.rs
@@ -208,7 +208,7 @@ impl StaticMutex {
         // After we've failed the fast path, then we delegate to the differnet
         // locking protocols for green/native tasks. This will select two tasks
         // to continue further (one native, one green).
-        let t: ~Task = Local::take();
+        let t: Box<Task> = Local::take();
         let can_block = t.can_block();
         let native_bit;
         if can_block {
@@ -244,7 +244,7 @@ impl StaticMutex {
         // regularly in native/green contention. Due to try_lock and the header
         // of lock stealing the lock, it's also possible for native/native
         // contention to hit this location, but as less common.
-        let t: ~Task = Local::take();
+        let t: Box<Task> = Local::take();
         t.deschedule(1, |task| {
             let task = unsafe { task.cast_to_uint() };
 
@@ -308,7 +308,7 @@ impl StaticMutex {
 
     // Tasks which can block are super easy. These tasks just call the blocking
     // `lock()` function on an OS mutex
-    fn native_lock(&self, t: ~Task) {
+    fn native_lock(&self, t: Box<Task>) {
         Local::put(t);
         unsafe { self.lock.lock_noguard(); }
     }
@@ -317,7 +317,7 @@ impl StaticMutex {
         unsafe { self.lock.unlock_noguard(); }
     }
 
-    fn green_lock(&self, t: ~Task) {
+    fn green_lock(&self, t: Box<Task>) {
         // Green threads flag their presence with an atomic counter, and if they
         // fail to be the first to the mutex, they enqueue themselves on a
         // concurrent internal queue with a stack-allocated node.
diff --git a/src/libsync/raw.rs b/src/libsync/raw.rs
index 6ab833a19ef..313720fa932 100644
--- a/src/libsync/raw.rs
+++ b/src/libsync/raw.rs
@@ -167,7 +167,9 @@ impl<Q: Send> Sem<Q> {
 #[unsafe_destructor]
 impl<Q: Send> Drop for Sem<Q> {
     fn drop(&mut self) {
-        let _waiters: ~SemInner<Q> = unsafe { cast::transmute(self.inner) };
+        let _waiters: Box<SemInner<Q>> = unsafe {
+            cast::transmute(self.inner)
+        };
         self.inner = 0 as *();
     }
 }
@@ -835,7 +837,7 @@ mod tests {
         let m = Arc::new(Mutex::new());
         let m2 = m.clone();
 
-        let result: result::Result<(), ~Any:Send> = task::try(proc() {
+        let result: result::Result<(), Box<Any:Send>> = task::try(proc() {
             let _lock = m2.lock();
             fail!();
         });
@@ -1075,7 +1077,7 @@ mod tests {
         let x = Arc::new(RWLock::new());
         let x2 = x.clone();
 
-        let result: result::Result<(), ~Any:Send> = task::try(proc() {
+        let result: result::Result<(), Box<Any:Send>> = task::try(proc() {
             lock_rwlock_in_mode(&x2, mode1, || {
                 fail!();
             })
diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
index 46bbc8768c9..ee61ce24c30 100644
--- a/src/libsyntax/ast_util.rs
+++ b/src/libsyntax/ast_util.rs
@@ -121,7 +121,7 @@ pub fn is_shift_binop(b: BinOp) -> bool {
 pub fn unop_to_str(op: UnOp) -> &'static str {
     match op {
       UnBox => "@",
-      UnUniq => "~",
+      UnUniq => "box() ",
       UnDeref => "*",
       UnNot => "!",
       UnNeg => "-",
diff --git a/src/libsyntax/diagnostic.rs b/src/libsyntax/diagnostic.rs
index f09072e0bc6..ee03046b6d6 100644
--- a/src/libsyntax/diagnostic.rs
+++ b/src/libsyntax/diagnostic.rs
@@ -111,7 +111,7 @@ impl SpanHandler {
 // others log errors for later reporting.
 pub struct Handler {
     err_count: Cell<uint>,
-    emit: RefCell<~Emitter:Send>,
+    emit: RefCell<Box<Emitter:Send>>,
 }
 
 impl Handler {
@@ -180,7 +180,7 @@ pub fn default_handler() -> Handler {
     mk_handler(box EmitterWriter::stderr())
 }
 
-pub fn mk_handler(e: ~Emitter:Send) -> Handler {
+pub fn mk_handler(e: Box<Emitter:Send>) -> Handler {
     Handler {
         err_count: Cell::new(0),
         emit: RefCell::new(e),
@@ -253,7 +253,7 @@ pub struct EmitterWriter {
 
 enum Destination {
     Terminal(term::Terminal<io::stdio::StdWriter>),
-    Raw(~Writer:Send),
+    Raw(Box<Writer:Send>),
 }
 
 impl EmitterWriter {
@@ -270,7 +270,7 @@ impl EmitterWriter {
         }
     }
 
-    pub fn new(dst: ~Writer:Send) -> EmitterWriter {
+    pub fn new(dst: Box<Writer:Send>) -> EmitterWriter {
         EmitterWriter { dst: Raw(dst) }
     }
 }
diff --git a/src/libsyntax/ext/asm.rs b/src/libsyntax/ext/asm.rs
index 9b362f8d942..b9c8be290ca 100644
--- a/src/libsyntax/ext/asm.rs
+++ b/src/libsyntax/ext/asm.rs
@@ -20,6 +20,7 @@ use parse;
 use parse::token::InternedString;
 use parse::token;
 
+
 enum State {
     Asm,
     Outputs,
@@ -45,7 +46,7 @@ impl State {
 static OPTIONS: &'static [&'static str] = &["volatile", "alignstack", "intel"];
 
 pub fn expand_asm(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
-               -> ~base::MacResult {
+                  -> Box<base::MacResult> {
     let mut p = parse::new_parser_from_tts(cx.parse_sess(),
                                            cx.cfg(),
                                            tts.iter()
diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
index cee6216b23f..01ec4c84b68 100644
--- a/src/libsyntax/ext/base.rs
+++ b/src/libsyntax/ext/base.rs
@@ -50,19 +50,19 @@ pub trait MacroExpander {
               ecx: &mut ExtCtxt,
               span: Span,
               token_tree: &[ast::TokenTree])
-              -> ~MacResult;
+              -> Box<MacResult>;
 }
 
 pub type MacroExpanderFn =
     fn(ecx: &mut ExtCtxt, span: codemap::Span, token_tree: &[ast::TokenTree])
-       -> ~MacResult;
+       -> Box<MacResult>;
 
 impl MacroExpander for BasicMacroExpander {
     fn expand(&self,
               ecx: &mut ExtCtxt,
               span: Span,
               token_tree: &[ast::TokenTree])
-              -> ~MacResult {
+              -> Box<MacResult> {
         (self.expander)(ecx, span, token_tree)
     }
 }
@@ -78,7 +78,7 @@ pub trait IdentMacroExpander {
               sp: Span,
               ident: ast::Ident,
               token_tree: Vec<ast::TokenTree> )
-              -> ~MacResult;
+              -> Box<MacResult>;
 }
 
 impl IdentMacroExpander for BasicIdentMacroExpander {
@@ -87,13 +87,13 @@ impl IdentMacroExpander for BasicIdentMacroExpander {
               sp: Span,
               ident: ast::Ident,
               token_tree: Vec<ast::TokenTree> )
-              -> ~MacResult {
+              -> Box<MacResult> {
         (self.expander)(cx, sp, ident, token_tree)
     }
 }
 
 pub type IdentMacroExpanderFn =
-    fn(&mut ExtCtxt, Span, ast::Ident, Vec<ast::TokenTree> ) -> ~MacResult;
+    fn(&mut ExtCtxt, Span, ast::Ident, Vec<ast::TokenTree>) -> Box<MacResult>;
 
 pub type MacroCrateRegistrationFun =
     fn(|ast::Name, SyntaxExtension|);
@@ -130,8 +130,8 @@ pub struct MacExpr {
     e: @ast::Expr
 }
 impl MacExpr {
-    pub fn new(e: @ast::Expr) -> ~MacResult {
-        box MacExpr { e: e } as ~MacResult
+    pub fn new(e: @ast::Expr) -> Box<MacResult> {
+        box MacExpr { e: e } as Box<MacResult>
     }
 }
 impl MacResult for MacExpr {
@@ -144,8 +144,8 @@ pub struct MacItem {
     i: @ast::Item
 }
 impl MacItem {
-    pub fn new(i: @ast::Item) -> ~MacResult {
-        box MacItem { i: i } as ~MacResult
+    pub fn new(i: @ast::Item) -> Box<MacResult> {
+        box MacItem { i: i } as Box<MacResult>
     }
 }
 impl MacResult for MacItem {
@@ -173,8 +173,8 @@ impl DummyResult {
     ///
     /// Use this as a return value after hitting any errors and
     /// calling `span_err`.
-    pub fn any(sp: Span) -> ~MacResult {
-        box DummyResult { expr_only: false, span: sp } as ~MacResult
+    pub fn any(sp: Span) -> Box<MacResult> {
+        box DummyResult { expr_only: false, span: sp } as Box<MacResult>
     }
 
     /// Create a default MacResult that can only be an expression.
@@ -182,8 +182,8 @@ impl DummyResult {
     /// Use this for macros that must expand to an expression, so even
     /// if an error is encountered internally, the user will recieve
     /// an error that they also used it in the wrong place.
-    pub fn expr(sp: Span) -> ~MacResult {
-        box DummyResult { expr_only: true, span: sp } as ~MacResult
+    pub fn expr(sp: Span) -> Box<MacResult> {
+        box DummyResult { expr_only: true, span: sp } as Box<MacResult>
     }
 
     /// A plain dummy expression.
@@ -229,13 +229,13 @@ pub enum SyntaxExtension {
     /// A normal, function-like syntax extension.
     ///
     /// `bytes!` is a `NormalTT`.
-    NormalTT(~MacroExpander:'static, Option<Span>),
+    NormalTT(Box<MacroExpander:'static>, Option<Span>),
 
     /// A function-like syntax extension that has an extra ident before
     /// the block.
     ///
     /// `macro_rules!` is an `IdentTT`.
-    IdentTT(~IdentMacroExpander:'static, Option<Span>),
+    IdentTT(Box<IdentMacroExpander:'static>, Option<Span>),
 }
 
 pub struct BlockInfo {
diff --git a/src/libsyntax/ext/bytes.rs b/src/libsyntax/ext/bytes.rs
index c6349d616ec..06b50e37cbd 100644
--- a/src/libsyntax/ext/bytes.rs
+++ b/src/libsyntax/ext/bytes.rs
@@ -16,7 +16,9 @@ use ext::base::*;
 use ext::base;
 use ext::build::AstBuilder;
 
-pub fn expand_syntax_ext(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) -> ~base::MacResult {
+
+pub fn expand_syntax_ext(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
+                         -> Box<base::MacResult> {
     // Gather all argument expressions
     let exprs = match get_exprs_from_tts(cx, sp, tts) {
         None => return DummyResult::expr(sp),
diff --git a/src/libsyntax/ext/cfg.rs b/src/libsyntax/ext/cfg.rs
index 8cd899738bf..3e74b2680e0 100644
--- a/src/libsyntax/ext/cfg.rs
+++ b/src/libsyntax/ext/cfg.rs
@@ -26,7 +26,9 @@ use parse::token::InternedString;
 use parse::token;
 use parse;
 
-pub fn expand_cfg(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) -> ~base::MacResult {
+
+pub fn expand_cfg(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
+                  -> Box<base::MacResult> {
     let mut p = parse::new_parser_from_tts(cx.parse_sess(),
                                            cx.cfg(),
                                            tts.iter()
diff --git a/src/libsyntax/ext/concat.rs b/src/libsyntax/ext/concat.rs
index fe7fa636e7d..7c6c9892002 100644
--- a/src/libsyntax/ext/concat.rs
+++ b/src/libsyntax/ext/concat.rs
@@ -18,7 +18,8 @@ use std::strbuf::StrBuf;
 
 pub fn expand_syntax_ext(cx: &mut base::ExtCtxt,
                          sp: codemap::Span,
-                         tts: &[ast::TokenTree]) -> ~base::MacResult {
+                         tts: &[ast::TokenTree])
+                         -> Box<base::MacResult> {
     let es = match base::get_exprs_from_tts(cx, sp, tts) {
         Some(e) => e,
         None => return base::DummyResult::expr(sp)
diff --git a/src/libsyntax/ext/concat_idents.rs b/src/libsyntax/ext/concat_idents.rs
index 9513c15c3d0..0e168e7b33b 100644
--- a/src/libsyntax/ext/concat_idents.rs
+++ b/src/libsyntax/ext/concat_idents.rs
@@ -19,7 +19,7 @@ use parse::token::{str_to_ident};
 use std::strbuf::StrBuf;
 
 pub fn expand_syntax_ext(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
-    -> ~base::MacResult {
+                         -> Box<base::MacResult> {
     let mut res_str = StrBuf::new();
     for (i, e) in tts.iter().enumerate() {
         if i & 1 == 1 {
diff --git a/src/libsyntax/ext/deriving/generic.rs b/src/libsyntax/ext/deriving/generic.rs
index bf886e51885..a3f9eaee892 100644
--- a/src/libsyntax/ext/deriving/generic.rs
+++ b/src/libsyntax/ext/deriving/generic.rs
@@ -571,7 +571,7 @@ impl<'a> MethodDef<'a> {
                 Self if nonstatic  => {
                     self_args.push(arg_expr);
                 }
-                Ptr(~Self, _) if nonstatic => {
+                Ptr(box Self, _) if nonstatic => {
                     self_args.push(cx.expr_deref(trait_.span, arg_expr))
                 }
                 _ => {
diff --git a/src/libsyntax/ext/deriving/ty.rs b/src/libsyntax/ext/deriving/ty.rs
index 769bbe2fc4e..602245b4c47 100644
--- a/src/libsyntax/ext/deriving/ty.rs
+++ b/src/libsyntax/ext/deriving/ty.rs
@@ -20,6 +20,7 @@ use ext::build::AstBuilder;
 use codemap::{Span,respan};
 use owned_slice::OwnedSlice;
 
+
 /// The types of pointers
 pub enum PtrTy<'a> {
     Send, // ~
@@ -31,7 +32,7 @@ pub enum PtrTy<'a> {
 pub struct Path<'a> {
     pub path: Vec<&'a str> ,
     pub lifetime: Option<&'a str>,
-    pub params: Vec<~Ty<'a>> ,
+    pub params: Vec<Box<Ty<'a>>>,
     pub global: bool,
 }
 
@@ -44,7 +45,7 @@ impl<'a> Path<'a> {
     }
     pub fn new_<'r>(path: Vec<&'r str> ,
                     lifetime: Option<&'r str>,
-                    params: Vec<~Ty<'r>> ,
+                    params: Vec<Box<Ty<'r>>>,
                     global: bool)
                     -> Path<'r> {
         Path {
@@ -80,8 +81,8 @@ impl<'a> Path<'a> {
 /// A type. Supports pointers (except for *), Self, and literals
 pub enum Ty<'a> {
     Self,
-    // &/~/@ Ty
-    Ptr(~Ty<'a>, PtrTy<'a>),
+    // &/Box/@ Ty
+    Ptr(Box<Ty<'a>>, PtrTy<'a>),
     // mod::mod::Type<[lifetime], [Params...]>, including a plain type
     // parameter, and things like `int`
     Literal(Path<'a>),
@@ -92,7 +93,7 @@ pub enum Ty<'a> {
 pub fn borrowed_ptrty<'r>() -> PtrTy<'r> {
     Borrowed(None, ast::MutImmutable)
 }
-pub fn borrowed<'r>(ty: ~Ty<'r>) -> Ty<'r> {
+pub fn borrowed<'r>(ty: Box<Ty<'r>>) -> Ty<'r> {
     Ptr(ty, borrowed_ptrty())
 }
 
diff --git a/src/libsyntax/ext/env.rs b/src/libsyntax/ext/env.rs
index 7229f5c1df9..ea3fef352be 100644
--- a/src/libsyntax/ext/env.rs
+++ b/src/libsyntax/ext/env.rs
@@ -24,7 +24,7 @@ use parse::token;
 use std::os;
 
 pub fn expand_option_env(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
-    -> ~base::MacResult {
+                         -> Box<base::MacResult> {
     let var = match get_single_str_from_tts(cx, sp, tts, "option_env!") {
         None => return DummyResult::expr(sp),
         Some(v) => v
@@ -60,7 +60,7 @@ pub fn expand_option_env(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
 }
 
 pub fn expand_env(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
-    -> ~base::MacResult {
+                  -> Box<base::MacResult> {
     let exprs = match get_exprs_from_tts(cx, sp, tts) {
         Some(ref exprs) if exprs.len() == 0 => {
             cx.span_err(sp, "env! takes 1 or 2 arguments");
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
index 734d07ccb8f..0dc62728e5c 100644
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax/ext/expand.rs
@@ -1100,12 +1100,6 @@ mod test {
         }
     }
 
-    //fn fake_print_crate(krate: &ast::Crate) {
-    //    let mut out = ~std::io::stderr() as ~std::io::Writer;
-    //    let mut s = pprust::rust_printer(out, get_ident_interner());
-    //    pprust::print_crate_(&mut s, krate);
-    //}
-
     fn expand_crate_str(crate_str: ~str) -> ast::Crate {
         let ps = parse::new_parse_sess();
         let crate_ast = string_to_parser(&ps, crate_str).parse_crate_mod();
diff --git a/src/libsyntax/ext/fmt.rs b/src/libsyntax/ext/fmt.rs
index 41c74ce9ae5..0907541eee0 100644
--- a/src/libsyntax/ext/fmt.rs
+++ b/src/libsyntax/ext/fmt.rs
@@ -15,8 +15,11 @@ use codemap::Span;
 use ext::base;
 use ext::build::AstBuilder;
 
-pub fn expand_syntax_ext(ecx: &mut base::ExtCtxt, sp: Span,
-                         _tts: &[ast::TokenTree]) -> ~base::MacResult {
+
+pub fn expand_syntax_ext(ecx: &mut base::ExtCtxt,
+                         sp: Span,
+                         _tts: &[ast::TokenTree])
+                         -> Box<base::MacResult> {
     ecx.span_err(sp, "`fmt!` is deprecated, use `format!` instead");
     ecx.parse_sess.span_diagnostic.span_note(sp,
         "see http://static.rust-lang.org/doc/master/std/fmt/index.html \
diff --git a/src/libsyntax/ext/format.rs b/src/libsyntax/ext/format.rs
index 0d856fb689d..fc3136996ae 100644
--- a/src/libsyntax/ext/format.rs
+++ b/src/libsyntax/ext/format.rs
@@ -805,7 +805,7 @@ impl<'a, 'b> Context<'a, 'b> {
 }
 
 pub fn expand_args(ecx: &mut ExtCtxt, sp: Span,
-                   tts: &[ast::TokenTree]) -> ~base::MacResult {
+                   tts: &[ast::TokenTree]) -> Box<base::MacResult> {
 
     match parse_args(ecx, sp, tts) {
         (extra, Some((efmt, args, order, names))) => {
diff --git a/src/libsyntax/ext/log_syntax.rs b/src/libsyntax/ext/log_syntax.rs
index 666bc486fbf..486d060da77 100644
--- a/src/libsyntax/ext/log_syntax.rs
+++ b/src/libsyntax/ext/log_syntax.rs
@@ -18,7 +18,7 @@ use std::rc::Rc;
 pub fn expand_syntax_ext(cx: &mut base::ExtCtxt,
                          sp: codemap::Span,
                          tt: &[ast::TokenTree])
-                      -> ~base::MacResult {
+                         -> Box<base::MacResult> {
 
     cx.print_backtrace();
     println!("{}", print::pprust::tt_to_str(&ast::TTDelim(
diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs
index fc7f7722354..4d8be9bab76 100644
--- a/src/libsyntax/ext/quote.rs
+++ b/src/libsyntax/ext/quote.rs
@@ -17,6 +17,7 @@ use parse::token::*;
 use parse::token;
 use parse;
 
+
 /**
 *
 * Quasiquoting works via token trees.
@@ -312,7 +313,8 @@ pub mod rt {
 
 pub fn expand_quote_tokens(cx: &mut ExtCtxt,
                            sp: Span,
-                           tts: &[ast::TokenTree]) -> ~base::MacResult {
+                           tts: &[ast::TokenTree])
+                           -> Box<base::MacResult> {
     let (cx_expr, expr) = expand_tts(cx, sp, tts);
     let expanded = expand_wrapper(cx, sp, cx_expr, expr);
     base::MacExpr::new(expanded)
@@ -320,14 +322,15 @@ pub fn expand_quote_tokens(cx: &mut ExtCtxt,
 
 pub fn expand_quote_expr(cx: &mut ExtCtxt,
                          sp: Span,
-                         tts: &[ast::TokenTree]) -> ~base::MacResult {
+                         tts: &[ast::TokenTree]) -> Box<base::MacResult> {
     let expanded = expand_parse_call(cx, sp, "parse_expr", Vec::new(), tts);
     base::MacExpr::new(expanded)
 }
 
 pub fn expand_quote_item(cx: &mut ExtCtxt,
                          sp: Span,
-                         tts: &[ast::TokenTree]) -> ~base::MacResult {
+                         tts: &[ast::TokenTree])
+                         -> Box<base::MacResult> {
     let e_attrs = cx.expr_vec_ng(sp);
     let expanded = expand_parse_call(cx, sp, "parse_item",
                                     vec!(e_attrs), tts);
@@ -336,7 +339,8 @@ pub fn expand_quote_item(cx: &mut ExtCtxt,
 
 pub fn expand_quote_pat(cx: &mut ExtCtxt,
                         sp: Span,
-                        tts: &[ast::TokenTree]) -> ~base::MacResult {
+                        tts: &[ast::TokenTree])
+                        -> Box<base::MacResult> {
     let e_refutable = cx.expr_lit(sp, ast::LitBool(true));
     let expanded = expand_parse_call(cx, sp, "parse_pat",
                                     vec!(e_refutable), tts);
@@ -345,7 +349,8 @@ pub fn expand_quote_pat(cx: &mut ExtCtxt,
 
 pub fn expand_quote_ty(cx: &mut ExtCtxt,
                        sp: Span,
-                       tts: &[ast::TokenTree]) -> ~base::MacResult {
+                       tts: &[ast::TokenTree])
+                       -> Box<base::MacResult> {
     let e_param_colons = cx.expr_lit(sp, ast::LitBool(false));
     let expanded = expand_parse_call(cx, sp, "parse_ty",
                                      vec!(e_param_colons), tts);
@@ -354,7 +359,8 @@ pub fn expand_quote_ty(cx: &mut ExtCtxt,
 
 pub fn expand_quote_stmt(cx: &mut ExtCtxt,
                          sp: Span,
-                         tts: &[ast::TokenTree]) -> ~base::MacResult {
+                         tts: &[ast::TokenTree])
+                         -> Box<base::MacResult> {
     let e_attrs = cx.expr_vec_ng(sp);
     let expanded = expand_parse_call(cx, sp, "parse_stmt",
                                     vec!(e_attrs), tts);
diff --git a/src/libsyntax/ext/source_util.rs b/src/libsyntax/ext/source_util.rs
index 7f1d8172255..e221ab80d7b 100644
--- a/src/libsyntax/ext/source_util.rs
+++ b/src/libsyntax/ext/source_util.rs
@@ -29,7 +29,7 @@ use std::str;
 
 /* line!(): expands to the current line number */
 pub fn expand_line(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
-    -> ~base::MacResult {
+                   -> Box<base::MacResult> {
     base::check_zero_tts(cx, sp, tts, "line!");
 
     let topmost = topmost_expn_info(cx.backtrace().unwrap());
@@ -40,7 +40,7 @@ pub fn expand_line(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
 
 /* col!(): expands to the current column number */
 pub fn expand_col(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
-    -> ~base::MacResult {
+                  -> Box<base::MacResult> {
     base::check_zero_tts(cx, sp, tts, "col!");
 
     let topmost = topmost_expn_info(cx.backtrace().unwrap());
@@ -52,7 +52,7 @@ pub fn expand_col(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
 /* The filemap (`loc.file`) contains a bunch more information we could spit
  * out if we wanted. */
 pub fn expand_file(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
-    -> ~base::MacResult {
+                   -> Box<base::MacResult> {
     base::check_zero_tts(cx, sp, tts, "file!");
 
     let topmost = topmost_expn_info(cx.backtrace().unwrap());
@@ -62,13 +62,13 @@ pub fn expand_file(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
 }
 
 pub fn expand_stringify(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
-    -> ~base::MacResult {
+                        -> Box<base::MacResult> {
     let s = pprust::tts_to_str(tts);
     base::MacExpr::new(cx.expr_str(sp, token::intern_and_get_ident(s)))
 }
 
 pub fn expand_mod(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
-    -> ~base::MacResult {
+                  -> Box<base::MacResult> {
     base::check_zero_tts(cx, sp, tts, "module_path!");
     let string = cx.mod_path()
                    .iter()
@@ -82,7 +82,7 @@ pub fn expand_mod(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
 // This is generally a bad idea because it's going to behave
 // unhygienically.
 pub fn expand_include(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
-    -> ~base::MacResult {
+                      -> Box<base::MacResult> {
     let file = match get_single_str_from_tts(cx, sp, tts, "include!") {
         Some(f) => f,
         None => return DummyResult::expr(sp),
@@ -100,7 +100,7 @@ pub fn expand_include(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
 
 // include_str! : read the given file, insert it as a literal string expr
 pub fn expand_include_str(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
-    -> ~base::MacResult {
+                          -> Box<base::MacResult> {
     let file = match get_single_str_from_tts(cx, sp, tts, "include_str!") {
         Some(f) => f,
         None => return DummyResult::expr(sp)
@@ -131,8 +131,7 @@ pub fn expand_include_str(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
 }
 
 pub fn expand_include_bin(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
-        -> ~base::MacResult
-{
+                          -> Box<base::MacResult> {
     let file = match get_single_str_from_tts(cx, sp, tts, "include_bin!") {
         Some(f) => f,
         None => return DummyResult::expr(sp)
diff --git a/src/libsyntax/ext/trace_macros.rs b/src/libsyntax/ext/trace_macros.rs
index d428251604c..77324632664 100644
--- a/src/libsyntax/ext/trace_macros.rs
+++ b/src/libsyntax/ext/trace_macros.rs
@@ -14,10 +14,11 @@ use ext::base::ExtCtxt;
 use ext::base;
 use parse::token::{keywords, is_keyword};
 
+
 pub fn expand_trace_macros(cx: &mut ExtCtxt,
                            sp: Span,
                            tt: &[ast::TokenTree])
-                        -> ~base::MacResult {
+                           -> Box<base::MacResult> {
     match tt {
         [ast::TTTok(_, ref tok)] if is_keyword(keywords::True, tok) => {
             cx.set_trace_macros(true);
diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs
index 4c426bef12e..ee3ff0c389e 100644
--- a/src/libsyntax/ext/tt/macro_parser.rs
+++ b/src/libsyntax/ext/tt/macro_parser.rs
@@ -102,7 +102,7 @@ pub struct MatcherPos {
     elts: Vec<ast::Matcher> , // maybe should be <'>? Need to understand regions.
     sep: Option<Token>,
     idx: uint,
-    up: Option<~MatcherPos>,
+    up: Option<Box<MatcherPos>>,
     matches: Vec<Vec<Rc<NamedMatch>>>,
     match_lo: uint, match_hi: uint,
     sp_lo: BytePos,
@@ -120,7 +120,7 @@ pub fn count_names(ms: &[Matcher]) -> uint {
 }
 
 pub fn initial_matcher_pos(ms: Vec<Matcher> , sep: Option<Token>, lo: BytePos)
-                        -> ~MatcherPos {
+                           -> Box<MatcherPos> {
     let mut match_idx_hi = 0u;
     for elt in ms.iter() {
         match elt.node {
diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs
index ab0266cedaa..5a02acdae1c 100644
--- a/src/libsyntax/ext/tt/macro_rules.rs
+++ b/src/libsyntax/ext/tt/macro_rules.rs
@@ -95,7 +95,7 @@ impl MacroExpander for MacroRulesMacroExpander {
               cx: &mut ExtCtxt,
               sp: Span,
               arg: &[ast::TokenTree])
-              -> ~MacResult {
+              -> Box<MacResult> {
         generic_extension(cx,
                           sp,
                           self.name,
@@ -121,7 +121,7 @@ fn generic_extension(cx: &ExtCtxt,
                      arg: &[ast::TokenTree],
                      lhses: &[Rc<NamedMatch>],
                      rhses: &[Rc<NamedMatch>])
-                     -> ~MacResult {
+                     -> Box<MacResult> {
     if cx.trace_macros() {
         println!("{}! \\{ {} \\}",
                  token::get_ident(name),
@@ -171,7 +171,7 @@ fn generic_extension(cx: &ExtCtxt,
                 // Weird, but useful for X-macros.
                 return box ParserAnyMacro {
                     parser: RefCell::new(p),
-                } as ~MacResult
+                } as Box<MacResult>
               }
               Failure(sp, ref msg) => if sp.lo >= best_fail_spot.lo {
                 best_fail_spot = sp;
@@ -193,7 +193,7 @@ pub fn add_new_extension(cx: &mut ExtCtxt,
                          sp: Span,
                          name: Ident,
                          arg: Vec<ast::TokenTree> )
-                         -> ~base::MacResult {
+                         -> Box<base::MacResult> {
     // these spans won't matter, anyways
     fn ms(m: Matcher_) -> Matcher {
         Spanned {
@@ -250,5 +250,5 @@ pub fn add_new_extension(cx: &mut ExtCtxt,
             name: token::get_ident(name).to_str(),
             ext: NormalTT(exp, Some(sp))
         }))
-    } as ~MacResult
+    } as Box<MacResult>
 }
diff --git a/src/libsyntax/ext/tt/transcribe.rs b/src/libsyntax/ext/tt/transcribe.rs
index 8fa4857cab0..f6bee033553 100644
--- a/src/libsyntax/ext/tt/transcribe.rs
+++ b/src/libsyntax/ext/tt/transcribe.rs
@@ -254,7 +254,7 @@ pub fn tt_next_token(r: &mut TtReader) -> TokenAndSpan {
                     /* sidestep the interpolation tricks for ident because
                        (a) idents can be in lots of places, so it'd be a pain
                        (b) we actually can, since it's a token. */
-                    MatchedNonterminal(NtIdent(~sn,b)) => {
+                    MatchedNonterminal(NtIdent(box sn, b)) => {
                         r.cur_span = sp;
                         r.cur_tok = IDENT(sn,b);
                         return ret_val;
diff --git a/src/libsyntax/parse/obsolete.rs b/src/libsyntax/parse/obsolete.rs
index d09a002e117..b9157e0043d 100644
--- a/src/libsyntax/parse/obsolete.rs
+++ b/src/libsyntax/parse/obsolete.rs
@@ -40,6 +40,9 @@ pub enum ObsoleteSyntax {
     ObsoleteManagedPattern,
     ObsoleteManagedString,
     ObsoleteManagedVec,
+    ObsoleteOwnedType,
+    ObsoleteOwnedExpr,
+    ObsoleteOwnedPattern,
 }
 
 pub trait ParserObsoleteMethods {
@@ -126,6 +129,18 @@ impl<'a> ParserObsoleteMethods for Parser<'a> {
                 "managed vector",
                 "use `Rc<~[T]>` instead of a managed vector"
             ),
+            ObsoleteOwnedType => (
+                "`~` notation for owned pointers",
+                "use `Box<T>` in `std::owned` instead"
+            ),
+            ObsoleteOwnedExpr => (
+                "`~` notation for owned pointer allocation",
+                "use the `box` operator instead of `~`"
+            ),
+            ObsoleteOwnedPattern => (
+                "`~` notation for owned pointer patterns",
+                "use the `box` operator instead of `~`"
+            ),
         };
 
         self.report(sp, kind, kind_str, desc);
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 9ee770521fc..6e9fa2f92d8 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -273,7 +273,10 @@ struct ParsedItemsAndViewItems {
 
 /* ident is handled by common.rs */
 
-pub fn Parser<'a>(sess: &'a ParseSess, cfg: ast::CrateConfig, mut rdr: ~Reader:)
+pub fn Parser<'a>(
+              sess: &'a ParseSess,
+              cfg: ast::CrateConfig,
+              mut rdr: Box<Reader:>)
               -> Parser<'a> {
     let tok0 = rdr.next_token();
     let span = tok0.sp;
@@ -318,14 +321,14 @@ pub struct Parser<'a> {
     pub last_span: Span,
     pub cfg: CrateConfig,
     // the previous token or None (only stashed sometimes).
-    pub last_token: Option<~token::Token>,
+    pub last_token: Option<Box<token::Token>>,
     pub buffer: [TokenAndSpan, ..4],
     pub buffer_start: int,
     pub buffer_end: int,
     pub tokens_consumed: uint,
     pub restriction: restriction,
     pub quote_depth: uint, // not (yet) related to the quasiquoter
-    pub reader: ~Reader:,
+    pub reader: Box<Reader:>,
     pub interner: Rc<token::IdentInterner>,
     /// The set of seen errors about obsolete syntax. Used to suppress
     /// extra detail when the same error is seen twice
@@ -1221,6 +1224,14 @@ impl<'a> Parser<'a> {
         } else if self.token == token::TILDE {
             // OWNED POINTER
             self.bump();
+            match self.token {
+                token::IDENT(ref ident, _)
+                        if "str" == token::get_ident(*ident).get() => {
+                    // This is OK (for now).
+                }
+                token::LBRACKET => {}   // Also OK.
+                _ => self.obsolete(self.last_span, ObsoleteOwnedType),
+            };
             TyUniq(self.parse_ty(false))
         } else if self.token == token::BINOP(token::STAR) {
             // STAR POINTER (bare pointer?)
@@ -1445,7 +1456,7 @@ impl<'a> Parser<'a> {
             _ => None,
         };
         match found {
-            Some(INTERPOLATED(token::NtPath(~path))) => {
+            Some(INTERPOLATED(token::NtPath(box path))) => {
                 return PathAndBounds {
                     path: path,
                     bounds: None,
@@ -2258,9 +2269,13 @@ impl<'a> Parser<'a> {
             ex = match e.node {
               ExprVec(..) | ExprRepeat(..) => ExprVstore(e, ExprVstoreUniq),
               ExprLit(lit) if lit_is_str(lit) => {
+                  self.obsolete(self.last_span, ObsoleteOwnedExpr);
                   ExprVstore(e, ExprVstoreUniq)
               }
-              _ => self.mk_unary(UnUniq, e)
+              _ => {
+                  self.obsolete(self.last_span, ObsoleteOwnedExpr);
+                  self.mk_unary(UnUniq, e)
+              }
             };
           }
           token::IDENT(_, _) if self.is_keyword(keywords::Box) => {
@@ -2772,6 +2787,7 @@ impl<'a> Parser<'a> {
             let sub = self.parse_pat();
             pat = PatUniq(sub);
             hi = self.last_span.hi;
+            self.obsolete(self.last_span, ObsoleteOwnedPattern);
             return @ast::Pat {
                 id: ast::DUMMY_NODE_ID,
                 node: pat,
diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs
index 519a7d141d3..e4e71baad44 100644
--- a/src/libsyntax/parse/token.rs
+++ b/src/libsyntax/parse/token.rs
@@ -113,9 +113,9 @@ pub enum Nonterminal {
     NtPat( @ast::Pat),
     NtExpr(@ast::Expr),
     NtTy(  P<ast::Ty>),
-    NtIdent(~ast::Ident, bool),
+    NtIdent(Box<ast::Ident>, bool),
     NtMeta(@ast::MetaItem), // stuff inside brackets for attributes
-    NtPath(~ast::Path),
+    NtPath(Box<ast::Path>),
     NtTT(  @ast::TokenTree), // needs @ed to break a circularity
     NtMatchers(Vec<ast::Matcher> )
 }
diff --git a/src/libsyntax/print/pp.rs b/src/libsyntax/print/pp.rs
index 21215748fb4..a32cad70175 100644
--- a/src/libsyntax/print/pp.rs
+++ b/src/libsyntax/print/pp.rs
@@ -155,7 +155,7 @@ pub struct PrintStackElem {
 
 static SIZE_INFINITY: int = 0xffff;
 
-pub fn mk_printer(out: ~io::Writer, linewidth: uint) -> Printer {
+pub fn mk_printer(out: Box<io::Writer>, linewidth: uint) -> Printer {
     // Yes 3, it makes the ring buffers big enough to never
     // fall behind.
     let n: uint = 3 * linewidth;
@@ -262,7 +262,7 @@ pub fn mk_printer(out: ~io::Writer, linewidth: uint) -> Printer {
  * called 'print'.
  */
 pub struct Printer {
-    pub out: ~io::Writer,
+    pub out: Box<io::Writer>,
     buf_len: uint,
     margin: int, // width of lines we're constrained to
     space: int, // number of spaces left on line
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index fb823522612..310ca18e4fa 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -65,12 +65,12 @@ pub struct State<'a> {
     ann: &'a PpAnn
 }
 
-pub fn rust_printer(writer: ~io::Writer) -> State<'static> {
+pub fn rust_printer(writer: Box<io::Writer>) -> State<'static> {
     static NO_ANN: NoAnn = NoAnn;
     rust_printer_annotated(writer, &NO_ANN)
 }
 
-pub fn rust_printer_annotated<'a>(writer: ~io::Writer,
+pub fn rust_printer_annotated<'a>(writer: Box<io::Writer>,
                                   ann: &'a PpAnn) -> State<'a> {
     State {
         s: pp::mk_printer(writer, default_columns),
@@ -99,7 +99,7 @@ pub fn print_crate<'a>(cm: &'a CodeMap,
                        krate: &ast::Crate,
                        filename: ~str,
                        input: &mut io::Reader,
-                       out: ~io::Writer,
+                       out: Box<io::Writer>,
                        ann: &'a PpAnn,
                        is_expanded: bool) -> IoResult<()> {
     let (cmnts, lits) = comments::gather_comments_and_literals(
@@ -140,7 +140,7 @@ pub fn to_str(f: |&mut State| -> IoResult<()>) -> ~str {
         // FIXME(pcwalton): A nasty function to extract the string from an `io::Writer`
         // that we "know" to be a `MemWriter` that works around the lack of checked
         // downcasts.
-        let (_, wr): (uint, ~MemWriter) = cast::transmute_copy(&s.s.out);
+        let (_, wr): (uint, Box<MemWriter>) = cast::transmute_copy(&s.s.out);
         let result = str::from_utf8_owned(wr.get_ref().to_owned()).unwrap();
         cast::forget(wr);
         result
@@ -1113,7 +1113,7 @@ impl<'a> State<'a> {
 
     pub fn print_expr_vstore(&mut self, t: ast::ExprVstore) -> IoResult<()> {
         match t {
-            ast::ExprVstoreUniq => word(&mut self.s, "~"),
+            ast::ExprVstoreUniq => word(&mut self.s, "box "),
             ast::ExprVstoreSlice => word(&mut self.s, "&"),
             ast::ExprVstoreMutSlice => {
                 try!(word(&mut self.s, "&"));
@@ -1686,7 +1686,7 @@ impl<'a> State<'a> {
                 try!(self.pclose());
             }
             ast::PatUniq(inner) => {
-                try!(word(&mut self.s, "~"));
+                try!(word(&mut self.s, "box "));
                 try!(self.print_pat(inner));
             }
             ast::PatRegion(inner) => {
diff --git a/src/libterm/lib.rs b/src/libterm/lib.rs
index 9e3be403065..416c9243106 100644
--- a/src/libterm/lib.rs
+++ b/src/libterm/lib.rs
@@ -114,7 +114,7 @@ fn cap_for_attr(attr: attr::Attr) -> &'static str {
 pub struct Terminal<T> {
     num_colors: u16,
     out: T,
-    ti: ~TermInfo
+    ti: Box<TermInfo>,
 }
 
 impl<T: Writer> Terminal<T> {
diff --git a/src/libterm/terminfo/parser/compiled.rs b/src/libterm/terminfo/parser/compiled.rs
index db5dd2d5c19..2b50a20ac6a 100644
--- a/src/libterm/terminfo/parser/compiled.rs
+++ b/src/libterm/terminfo/parser/compiled.rs
@@ -159,8 +159,8 @@ pub static stringnames: &'static[&'static str] = &'static[ "cbt", "_", "cr", "cs
     "box1"];
 
 /// Parse a compiled terminfo entry, using long capability names if `longnames` is true
-pub fn parse(file: &mut io::Reader,
-             longnames: bool) -> Result<~TermInfo, ~str> {
+pub fn parse(file: &mut io::Reader, longnames: bool)
+             -> Result<Box<TermInfo>, ~str> {
     macro_rules! try( ($e:expr) => (
         match $e { Ok(e) => e, Err(e) => return Err(format!("{}", e)) }
     ) )
@@ -301,7 +301,7 @@ pub fn parse(file: &mut io::Reader,
 }
 
 /// Create a dummy TermInfo struct for msys terminals
-pub fn msys_terminfo() -> ~TermInfo {
+pub fn msys_terminfo() -> Box<TermInfo> {
     let mut strings = HashMap::new();
     strings.insert("sgr0".to_owned(), Vec::from_slice(bytes!("\x1b[0m")));
     strings.insert("bold".to_owned(), Vec::from_slice(bytes!("\x1b[1m")));
diff --git a/src/libterm/terminfo/searcher.rs b/src/libterm/terminfo/searcher.rs
index a491f7e863e..a4be7ed51fb 100644
--- a/src/libterm/terminfo/searcher.rs
+++ b/src/libterm/terminfo/searcher.rs
@@ -17,7 +17,7 @@ use std::os::getenv;
 use std::{os, str};
 
 /// Return path to database entry for `term`
-pub fn get_dbpath_for_term(term: &str) -> Option<~Path> {
+pub fn get_dbpath_for_term(term: &str) -> Option<Box<Path>> {
     if term.len() == 0 {
         return None;
     }
diff --git a/src/libtest/lib.rs b/src/libtest/lib.rs
index fa55444fe5b..4040e079224 100644
--- a/src/libtest/lib.rs
+++ b/src/libtest/lib.rs
@@ -132,7 +132,7 @@ pub enum TestFn {
     StaticMetricFn(proc(&mut MetricMap)),
     DynTestFn(proc():Send),
     DynMetricFn(proc(&mut MetricMap)),
-    DynBenchFn(~TDynBenchFn)
+    DynBenchFn(Box<TDynBenchFn>)
 }
 
 impl TestFn {
@@ -1001,8 +1001,8 @@ pub fn run_test(opts: &TestOpts,
             if nocapture {
                 drop((stdout, stderr));
             } else {
-                task.opts.stdout = Some(box stdout as ~Writer:Send);
-                task.opts.stderr = Some(box stderr as ~Writer:Send);
+                task.opts.stdout = Some(box stdout as Box<Writer:Send>);
+                task.opts.stderr = Some(box stderr as Box<Writer:Send>);
             }
             let result_future = task.future_result();
             task.spawn(testfn);
diff --git a/src/libuuid/lib.rs b/src/libuuid/lib.rs
index eef7cc67934..060c40b04d8 100644
--- a/src/libuuid/lib.rs
+++ b/src/libuuid/lib.rs
@@ -783,7 +783,7 @@ mod test {
     #[test]
     fn test_rand_rand() {
         let mut rng = rand::task_rng();
-        let u: ~Uuid = rand::Rand::rand(&mut rng);
+        let u: Box<Uuid> = rand::Rand::rand(&mut rng);
         let ub = u.as_bytes();
 
         assert!(ub.len() == 16);
diff --git a/src/test/auxiliary/issue-2380.rs b/src/test/auxiliary/issue-2380.rs
index a34ec980bda..c617c1b2d03 100644
--- a/src/test/auxiliary/issue-2380.rs
+++ b/src/test/auxiliary/issue-2380.rs
@@ -11,10 +11,11 @@
 #![crate_id="a"]
 #![crate_type = "lib"]
 
+
 pub trait i<T> { }
 
-pub fn f<T>() -> ~i<T> {
+pub fn f<T>() -> Box<i<T>> {
     impl<T> i<T> for () { }
 
-    ~() as ~i<T>
+    box() () as Box<i<T>>
 }
diff --git a/src/test/auxiliary/issue13507.rs b/src/test/auxiliary/issue13507.rs
index be066187be5..2b4df978cc8 100644
--- a/src/test/auxiliary/issue13507.rs
+++ b/src/test/auxiliary/issue13507.rs
@@ -59,7 +59,7 @@ pub mod testtypes {
     // Skipping ty_box
 
     // Tests ty_uniq (of u8)
-    pub type FooUniq = ~u8;
+    pub type FooUniq = Box<u8>;
 
     // As with ty_str, what type should be used for ty_vec?
 
diff --git a/src/test/auxiliary/macro_crate_outlive_expansion_phase.rs b/src/test/auxiliary/macro_crate_outlive_expansion_phase.rs
index 4e933be5092..a2c7e3533d8 100644
--- a/src/test/auxiliary/macro_crate_outlive_expansion_phase.rs
+++ b/src/test/auxiliary/macro_crate_outlive_expansion_phase.rs
@@ -29,7 +29,7 @@ impl Drop for Foo {
 
 #[macro_registrar]
 pub fn registrar(_: |Name, SyntaxExtension|) {
-    local_data_key!(foo: ~Any:Send);
-    local_data::set(foo, ~Foo { foo: 10 } as ~Any:Send);
+    local_data_key!(foo: Box<Any:Send>);
+    local_data::set(foo, box Foo { foo: 10 } as Box<Any:Send>);
 }
 
diff --git a/src/test/auxiliary/macro_crate_test.rs b/src/test/auxiliary/macro_crate_test.rs
index 070bb6dfcb7..95f2a8c1ca1 100644
--- a/src/test/auxiliary/macro_crate_test.rs
+++ b/src/test/auxiliary/macro_crate_test.rs
@@ -27,7 +27,7 @@ macro_rules! unexported_macro (() => (3))
 #[macro_registrar]
 pub fn macro_registrar(register: |Name, SyntaxExtension|) {
     register(token::intern("make_a_1"),
-        NormalTT(~BasicMacroExpander {
+        NormalTT(box BasicMacroExpander {
             expander: expand_make_a_1,
             span: None,
         },
@@ -35,7 +35,8 @@ pub fn macro_registrar(register: |Name, SyntaxExtension|) {
     register(token::intern("into_foo"), ItemModifier(expand_into_foo));
 }
 
-fn expand_make_a_1(cx: &mut ExtCtxt, sp: Span, tts: &[TokenTree]) -> ~MacResult {
+fn expand_make_a_1(cx: &mut ExtCtxt, sp: Span, tts: &[TokenTree])
+                   -> Box<MacResult> {
     if !tts.is_empty() {
         cx.span_fatal(sp, "make_a_1 takes no arguments");
     }
diff --git a/src/test/auxiliary/syntax-extension-with-dll-deps-2.rs b/src/test/auxiliary/syntax-extension-with-dll-deps-2.rs
index 8156e7f0e34..93b56a7600d 100644
--- a/src/test/auxiliary/syntax-extension-with-dll-deps-2.rs
+++ b/src/test/auxiliary/syntax-extension-with-dll-deps-2.rs
@@ -25,14 +25,15 @@ use syntax::parse::token;
 #[macro_registrar]
 pub fn macro_registrar(register: |Name, SyntaxExtension|) {
     register(token::intern("foo"),
-        NormalTT(~BasicMacroExpander {
+        NormalTT(box BasicMacroExpander {
             expander: expand_foo,
             span: None,
         },
         None));
 }
 
-fn expand_foo(cx: &mut ExtCtxt, sp: Span, tts: &[TokenTree]) -> ~MacResult {
+fn expand_foo(cx: &mut ExtCtxt, sp: Span, tts: &[TokenTree])
+              -> Box<MacResult> {
     let answer = other::the_answer();
     MacExpr::new(quote_expr!(cx, $answer))
 }
diff --git a/src/test/bench/shootout-k-nucleotide-pipes.rs b/src/test/bench/shootout-k-nucleotide-pipes.rs
index dd6e504f1de..659270b5554 100644
--- a/src/test/bench/shootout-k-nucleotide-pipes.rs
+++ b/src/test/bench/shootout-k-nucleotide-pipes.rs
@@ -147,9 +147,9 @@ fn main() {
 
     let rdr = if os::getenv("RUST_BENCH").is_some() {
         let foo = include_bin!("shootout-k-nucleotide.data");
-        ~MemReader::new(Vec::from_slice(foo)) as ~Reader
+        box MemReader::new(Vec::from_slice(foo)) as Box<Reader>
     } else {
-        ~stdio::stdin() as ~Reader
+        box stdio::stdin() as Box<Reader>
     };
     let mut rdr = BufferedReader::new(rdr);
 
diff --git a/src/test/bench/shootout-k-nucleotide.rs b/src/test/bench/shootout-k-nucleotide.rs
index 865b3a03726..dfa287459f3 100644
--- a/src/test/bench/shootout-k-nucleotide.rs
+++ b/src/test/bench/shootout-k-nucleotide.rs
@@ -91,16 +91,16 @@ impl TableCallback for PrintCallback {
 struct Entry {
     code: Code,
     count: uint,
-    next: Option<~Entry>,
+    next: Option<Box<Entry>>,
 }
 
 struct Table {
     count: uint,
-    items: Vec<Option<~Entry>> }
+    items: Vec<Option<Box<Entry>>> }
 
 struct Items<'a> {
     cur: Option<&'a Entry>,
-    items: slice::Items<'a, Option<~Entry>>,
+    items: slice::Items<'a, Option<Box<Entry>>>,
 }
 
 impl Table {
@@ -114,7 +114,7 @@ impl Table {
     fn search_remainder<C:TableCallback>(item: &mut Entry, key: Code, c: C) {
         match item.next {
             None => {
-                let mut entry = ~Entry {
+                let mut entry = box Entry {
                     code: key,
                     count: 0,
                     next: None,
@@ -138,7 +138,7 @@ impl Table {
 
         {
             if self.items.get(index as uint).is_none() {
-                let mut entry = ~Entry {
+                let mut entry = box Entry {
                     code: key,
                     count: 0,
                     next: None,
diff --git a/src/test/bench/shootout-regex-dna.rs b/src/test/bench/shootout-regex-dna.rs
index 0f86b8043a0..f5409688bc6 100644
--- a/src/test/bench/shootout-regex-dna.rs
+++ b/src/test/bench/shootout-regex-dna.rs
@@ -34,9 +34,9 @@ fn count_matches(seq: &str, variant: &Regex) -> int {
 fn main() {
     let mut rdr = if std::os::getenv("RUST_BENCH").is_some() {
         let fd = io::File::open(&Path::new("shootout-k-nucleotide.data"));
-        ~io::BufferedReader::new(fd) as ~io::Reader
+        box io::BufferedReader::new(fd) as Box<io::Reader>
     } else {
-        ~io::stdin() as ~io::Reader
+        box io::stdin() as Box<io::Reader>
     };
     let mut seq = StrBuf::from_str(rdr.read_to_str().unwrap());
     let ilen = seq.len();
diff --git a/src/test/bench/sudoku.rs b/src/test/bench/sudoku.rs
index 3398cd84acd..bd47734c3da 100644
--- a/src/test/bench/sudoku.rs
+++ b/src/test/bench/sudoku.rs
@@ -15,8 +15,8 @@
 use std::io;
 use std::io::stdio::StdReader;
 use std::io::BufferedReader;
-use std::os;
 use std::num::Bitwise;
+use std::os;
 
 // Computes a single solution to a given 9x9 sudoku
 //
@@ -132,7 +132,7 @@ impl Sudoku {
     fn next_color(&mut self, row: u8, col: u8, start_color: u8) -> bool {
         if start_color < 10u8 {
             // colors not yet used
-            let mut avail = ~Colors::new(start_color);
+            let mut avail = box Colors::new(start_color);
 
             // drop colors already in use in neighbourhood
             self.drop_colors(avail, row, col);
diff --git a/src/test/bench/task-perf-alloc-unwind.rs b/src/test/bench/task-perf-alloc-unwind.rs
index 813a75cfb4d..fc47269ef87 100644
--- a/src/test/bench/task-perf-alloc-unwind.rs
+++ b/src/test/bench/task-perf-alloc-unwind.rs
@@ -24,7 +24,7 @@ enum List<T> {
 }
 
 enum UniqueList {
-    ULNil, ULCons(~UniqueList)
+    ULNil, ULCons(Box<UniqueList>)
 }
 
 fn main() {
@@ -53,8 +53,8 @@ type nillist = List<()>;
 
 struct State {
     managed: @nillist,
-    unique: ~nillist,
-    tuple: (@nillist, ~nillist),
+    unique: Box<nillist>,
+    tuple: (@nillist, Box<nillist>),
     vec: Vec<@nillist>,
     res: r
 }
@@ -85,8 +85,8 @@ fn recurse_or_fail(depth: int, st: Option<State>) {
           None => {
             State {
                 managed: @Nil,
-                unique: ~Nil,
-                tuple: (@Nil, ~Nil),
+                unique: box Nil,
+                tuple: (@Nil, box Nil),
                 vec: vec!(@Nil),
                 res: r(@Nil)
             }
@@ -94,9 +94,9 @@ fn recurse_or_fail(depth: int, st: Option<State>) {
           Some(st) => {
             State {
                 managed: @Cons((), st.managed),
-                unique: ~Cons((), @*st.unique),
+                unique: box Cons((), @*st.unique),
                 tuple: (@Cons((), st.tuple.ref0().clone()),
-                        ~Cons((), @*st.tuple.ref1().clone())),
+                        box Cons((), @*st.tuple.ref1().clone())),
                 vec: st.vec.clone().append(&[@Cons((), *st.vec.last().unwrap())]),
                 res: r(@Cons((), st.res._l))
             }
diff --git a/src/test/compile-fail/borrowck-bad-nested-calls-free.rs b/src/test/compile-fail/borrowck-bad-nested-calls-free.rs
index c142876c5c2..fd96b750fc1 100644
--- a/src/test/compile-fail/borrowck-bad-nested-calls-free.rs
+++ b/src/test/compile-fail/borrowck-bad-nested-calls-free.rs
@@ -11,8 +11,9 @@
 // Test that we detect nested calls that could free pointers evaluated
 // for earlier arguments.
 
-fn rewrite(v: &mut ~uint) -> uint {
-    *v = ~22;
+
+fn rewrite(v: &mut Box<uint>) -> uint {
+    *v = box 22;
     **v
 }
 
@@ -21,7 +22,7 @@ fn add(v: &uint, w: uint) -> uint {
 }
 
 fn implicit() {
-    let mut a = ~1;
+    let mut a = box 1;
 
     // Note the danger here:
     //
@@ -34,7 +35,7 @@ fn implicit() {
 }
 
 fn explicit() {
-    let mut a = ~1;
+    let mut a = box 1;
     add(
         &*a,
         rewrite(&mut a)); //~ ERROR cannot borrow
diff --git a/src/test/compile-fail/borrowck-bad-nested-calls-move.rs b/src/test/compile-fail/borrowck-bad-nested-calls-move.rs
index 622d2e78ee7..d1ab70e4aed 100644
--- a/src/test/compile-fail/borrowck-bad-nested-calls-move.rs
+++ b/src/test/compile-fail/borrowck-bad-nested-calls-move.rs
@@ -11,17 +11,18 @@
 // Test that we detect nested calls that could free pointers evaluated
 // for earlier arguments.
 
-fn rewrite(v: &mut ~uint) -> uint {
-    *v = ~22;
+
+fn rewrite(v: &mut Box<uint>) -> uint {
+    *v = box 22;
     **v
 }
 
-fn add(v: &uint, w: ~uint) -> uint {
+fn add(v: &uint, w: Box<uint>) -> uint {
     *v + *w
 }
 
 fn implicit() {
-    let mut a = ~1;
+    let mut a = box 1;
 
     // Note the danger here:
     //
@@ -34,7 +35,7 @@ fn implicit() {
 }
 
 fn explicit() {
-    let mut a = ~1;
+    let mut a = box 1;
     add(
         &*a,
         a); //~ ERROR cannot move
diff --git a/src/test/compile-fail/borrowck-borrow-from-owned-ptr.rs b/src/test/compile-fail/borrowck-borrow-from-owned-ptr.rs
index 1051c5829ec..c7695e0ff5f 100644
--- a/src/test/compile-fail/borrowck-borrow-from-owned-ptr.rs
+++ b/src/test/compile-fail/borrowck-borrow-from-owned-ptr.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 struct Foo {
   bar1: Bar,
   bar2: Bar
@@ -18,7 +19,7 @@ struct Bar {
   int2: int,
 }
 
-fn make_foo() -> ~Foo { fail!() }
+fn make_foo() -> Box<Foo> { fail!() }
 
 fn borrow_same_field_twice_mut_mut() {
     let mut foo = make_foo();
diff --git a/src/test/compile-fail/borrowck-borrow-overloaded-auto-deref-mut.rs b/src/test/compile-fail/borrowck-borrow-overloaded-auto-deref-mut.rs
index e43ac98aa98..1e04a3568c3 100644
--- a/src/test/compile-fail/borrowck-borrow-overloaded-auto-deref-mut.rs
+++ b/src/test/compile-fail/borrowck-borrow-overloaded-auto-deref-mut.rs
@@ -78,7 +78,7 @@ fn deref_extend_mut_field2<'a>(x: &'a mut Own<Point>) -> &'a mut int {
 }
 
 fn deref_extend_mut_field3<'a>(x: &'a mut Own<Point>) {
-    // Hmm, this is unfortunate, because with ~ it would work,
+    // Hmm, this is unfortunate, because with box it would work,
     // but it's presently the expected outcome. See `deref_extend_mut_field4`
     // for the workaround.
 
diff --git a/src/test/compile-fail/borrowck-borrowed-uniq-rvalue.rs b/src/test/compile-fail/borrowck-borrowed-uniq-rvalue.rs
index 20411723715..120223bbf60 100644
--- a/src/test/compile-fail/borrowck-borrowed-uniq-rvalue.rs
+++ b/src/test/compile-fail/borrowck-borrowed-uniq-rvalue.rs
@@ -15,9 +15,9 @@ use collections::HashMap;
 
 fn main() {
     let mut buggy_map: HashMap<uint, &uint> = HashMap::new();
-    buggy_map.insert(42, &*~1); //~ ERROR borrowed value does not live long enough
+    buggy_map.insert(42, &*box 1); //~ ERROR borrowed value does not live long enough
 
     // but it is ok if we use a temporary
-    let tmp = ~2;
+    let tmp = box 2;
     buggy_map.insert(43, &*tmp);
 }
diff --git a/src/test/compile-fail/borrowck-closures-mut-and-imm.rs b/src/test/compile-fail/borrowck-closures-mut-and-imm.rs
index 006f475b29d..ce8b17ea40b 100644
--- a/src/test/compile-fail/borrowck-closures-mut-and-imm.rs
+++ b/src/test/compile-fail/borrowck-closures-mut-and-imm.rs
@@ -11,6 +11,7 @@
 // Tests that two closures cannot simultaneously have mutable
 // and immutable access to the variable. Issue #6801.
 
+
 fn get(x: &int) -> int {
     *x
 }
@@ -50,27 +51,27 @@ fn e() {
 }
 
 fn f() {
-    let mut x = ~3;
+    let mut x = box 3;
     let c1 = || get(&*x);
     *x = 5; //~ ERROR cannot assign
 }
 
 fn g() {
     struct Foo {
-        f: ~int
+        f: Box<int>
     }
 
-    let mut x = ~Foo { f: ~3 };
+    let mut x = box Foo { f: box 3 };
     let c1 = || get(&*x.f);
     *x.f = 5; //~ ERROR cannot assign to `*x.f`
 }
 
 fn h() {
     struct Foo {
-        f: ~int
+        f: Box<int>
     }
 
-    let mut x = ~Foo { f: ~3 };
+    let mut x = box Foo { f: box 3 };
     let c1 = || get(&*x.f);
     let c2 = || *x.f = 5; //~ ERROR cannot borrow `x` as mutable
 }
diff --git a/src/test/compile-fail/borrowck-closures-two-mut.rs b/src/test/compile-fail/borrowck-closures-two-mut.rs
index 570249aed44..e1967d4e6df 100644
--- a/src/test/compile-fail/borrowck-closures-two-mut.rs
+++ b/src/test/compile-fail/borrowck-closures-two-mut.rs
@@ -12,6 +12,7 @@
 // access to the variable, whether that mutable access be used
 // for direct assignment or for taking mutable ref. Issue #6801.
 
+
 fn a() {
     let mut x = 3;
     let c1 = || x = 4;
@@ -43,10 +44,10 @@ fn d() {
 
 fn g() {
     struct Foo {
-        f: ~int
+        f: Box<int>
     }
 
-    let mut x = ~Foo { f: ~3 };
+    let mut x = box Foo { f: box 3 };
     let c1 = || set(&mut *x.f);
     let c2 = || set(&mut *x.f);
     //~^ ERROR cannot borrow `x` as mutable more than once
diff --git a/src/test/compile-fail/borrowck-closures-use-after-free.rs b/src/test/compile-fail/borrowck-closures-use-after-free.rs
index 38c13b1fce9..ec31160f0d5 100644
--- a/src/test/compile-fail/borrowck-closures-use-after-free.rs
+++ b/src/test/compile-fail/borrowck-closures-use-after-free.rs
@@ -12,6 +12,7 @@
 // cannot also be supplied a borrowed version of that
 // variable's contents. Issue #11192.
 
+
 struct Foo {
   x: int
 }
@@ -23,9 +24,9 @@ impl Drop for Foo {
 }
 
 fn main() {
-  let mut ptr = ~Foo { x: 0 };
+  let mut ptr = box Foo { x: 0 };
   let test = |foo: &Foo| {
-    ptr = ~Foo { x: ptr.x + 1 };
+    ptr = box Foo { x: ptr.x + 1 };
   };
   test(ptr); //~ ERROR cannot borrow `*ptr`
 }
diff --git a/src/test/compile-fail/borrowck-issue-2657-1.rs b/src/test/compile-fail/borrowck-issue-2657-1.rs
index 8bcd5f9a72e..9313473d6c9 100644
--- a/src/test/compile-fail/borrowck-issue-2657-1.rs
+++ b/src/test/compile-fail/borrowck-issue-2657-1.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 fn main() {
-let x = Some(~1);
+let x = Some(box 1);
 match x {
   Some(ref _y) => {
     let _a = x; //~ ERROR cannot move
diff --git a/src/test/compile-fail/borrowck-issue-2657-2.rs b/src/test/compile-fail/borrowck-issue-2657-2.rs
index fac805c57ca..39c3ae8fdfd 100644
--- a/src/test/compile-fail/borrowck-issue-2657-2.rs
+++ b/src/test/compile-fail/borrowck-issue-2657-2.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 fn main() {
-let x = Some(~1);
+let x = Some(box 1);
 match x {
   Some(ref y) => {
     let _b = *y; //~ ERROR cannot move out
diff --git a/src/test/compile-fail/borrowck-lend-flow-if.rs b/src/test/compile-fail/borrowck-lend-flow-if.rs
index 80b8770397f..b1ba057dc14 100644
--- a/src/test/compile-fail/borrowck-lend-flow-if.rs
+++ b/src/test/compile-fail/borrowck-lend-flow-if.rs
@@ -14,21 +14,22 @@
 // either genuine or would require more advanced changes.  The latter
 // cases are noted.
 
+
 fn borrow(_v: &int) {}
 fn borrow_mut(_v: &mut int) {}
 fn cond() -> bool { fail!() }
 fn for_func(_f: || -> bool) { fail!() }
 fn produce<T>() -> T { fail!(); }
 
-fn inc(v: &mut ~int) {
-    *v = ~(**v + 1);
+fn inc(v: &mut Box<int>) {
+    *v = box() (**v + 1);
 }
 
 fn pre_freeze_cond() {
     // In this instance, the freeze is conditional and starts before
     // the mut borrow.
 
-    let mut v = ~3;
+    let mut v = box 3;
     let _w;
     if cond() {
         _w = &v;
@@ -40,7 +41,7 @@ fn pre_freeze_else() {
     // In this instance, the freeze and mut borrow are on separate sides
     // of the if.
 
-    let mut v = ~3;
+    let mut v = box 3;
     let _w;
     if cond() {
         _w = &v;
diff --git a/src/test/compile-fail/borrowck-lend-flow-loop.rs b/src/test/compile-fail/borrowck-lend-flow-loop.rs
index 4f0c71457b2..831c4d3e824 100644
--- a/src/test/compile-fail/borrowck-lend-flow-loop.rs
+++ b/src/test/compile-fail/borrowck-lend-flow-loop.rs
@@ -14,19 +14,20 @@
 // either genuine or would require more advanced changes.  The latter
 // cases are noted.
 
+
 fn borrow(_v: &int) {}
 fn borrow_mut(_v: &mut int) {}
 fn cond() -> bool { fail!() }
 fn produce<T>() -> T { fail!(); }
 
-fn inc(v: &mut ~int) {
-    *v = ~(**v + 1);
+fn inc(v: &mut Box<int>) {
+    *v = box() (**v + 1);
 }
 
 fn loop_overarching_alias_mut() {
     // In this instance, the borrow encompasses the entire loop.
 
-    let mut v = ~3;
+    let mut v = box 3;
     let mut x = &mut v;
     **x += 1;
     loop {
@@ -37,19 +38,19 @@ fn loop_overarching_alias_mut() {
 fn block_overarching_alias_mut() {
     // In this instance, the borrow encompasses the entire closure call.
 
-    let mut v = ~3;
+    let mut v = box 3;
     let mut x = &mut v;
     for _ in range(0, 3) {
         borrow(v); //~ ERROR cannot borrow
     }
-    *x = ~5;
+    *x = box 5;
 }
 
 fn loop_aliased_mut() {
     // In this instance, the borrow is carried through the loop.
 
-    let mut v = ~3;
-    let mut w = ~4;
+    let mut v = box 3;
+    let mut w = box 4;
     let mut _x = &w;
     loop {
         borrow_mut(v); //~ ERROR cannot borrow
@@ -60,8 +61,8 @@ fn loop_aliased_mut() {
 fn while_aliased_mut() {
     // In this instance, the borrow is carried through the loop.
 
-    let mut v = ~3;
-    let mut w = ~4;
+    let mut v = box 3;
+    let mut w = box 4;
     let mut _x = &w;
     while cond() {
         borrow_mut(v); //~ ERROR cannot borrow
@@ -73,8 +74,8 @@ fn while_aliased_mut() {
 fn loop_aliased_mut_break() {
     // In this instance, the borrow is carried through the loop.
 
-    let mut v = ~3;
-    let mut w = ~4;
+    let mut v = box 3;
+    let mut w = box 4;
     let mut _x = &w;
     loop {
         borrow_mut(v);
@@ -87,8 +88,8 @@ fn loop_aliased_mut_break() {
 fn while_aliased_mut_break() {
     // In this instance, the borrow is carried through the loop.
 
-    let mut v = ~3;
-    let mut w = ~4;
+    let mut v = box 3;
+    let mut w = box 4;
     let mut _x = &w;
     while cond() {
         borrow_mut(v);
@@ -99,8 +100,8 @@ fn while_aliased_mut_break() {
 }
 
 fn while_aliased_mut_cond(cond: bool, cond2: bool) {
-    let mut v = ~3;
-    let mut w = ~4;
+    let mut v = box 3;
+    let mut w = box 4;
     let mut x = &mut w;
     while cond {
         **x += 1;
diff --git a/src/test/compile-fail/borrowck-lend-flow-match.rs b/src/test/compile-fail/borrowck-lend-flow-match.rs
index 9d234e0aaa6..ea0f5d34b72 100644
--- a/src/test/compile-fail/borrowck-lend-flow-match.rs
+++ b/src/test/compile-fail/borrowck-lend-flow-match.rs
@@ -37,24 +37,24 @@ fn guard() {
     // Here the guard performs a borrow. This borrow "infects" all
     // subsequent arms (but not the prior ones).
 
-    let mut a = ~3;
-    let mut b = ~4;
+    let mut a = box 3;
+    let mut b = box 4;
     let mut w = &*a;
     match 22 {
         _ if cond() => {
-            b = ~5;
+            b = box 5;
         }
 
         _ if link(&*b, &mut w) => {
-            b = ~6; //~ ERROR cannot assign
+            b = box 6; //~ ERROR cannot assign
         }
 
         _ => {
-            b = ~7; //~ ERROR cannot assign
+            b = box 7; //~ ERROR cannot assign
         }
     }
 
-    b = ~8; //~ ERROR cannot assign
+    b = box 8; //~ ERROR cannot assign
 }
 
 fn main() {}
diff --git a/src/test/compile-fail/borrowck-lend-flow.rs b/src/test/compile-fail/borrowck-lend-flow.rs
index 5e4e5bb1e73..54f326b479a 100644
--- a/src/test/compile-fail/borrowck-lend-flow.rs
+++ b/src/test/compile-fail/borrowck-lend-flow.rs
@@ -14,20 +14,21 @@
 // either genuine or would require more advanced changes.  The latter
 // cases are noted.
 
+
 fn borrow(_v: &int) {}
 fn borrow_mut(_v: &mut int) {}
 fn cond() -> bool { fail!() }
 fn for_func(_f: || -> bool) { fail!() }
 fn produce<T>() -> T { fail!(); }
 
-fn inc(v: &mut ~int) {
-    *v = ~(**v + 1);
+fn inc(v: &mut Box<int>) {
+    *v = box() (**v + 1);
 }
 
 fn pre_freeze() {
     // In this instance, the freeze starts before the mut borrow.
 
-    let mut v = ~3;
+    let mut v = box 3;
     let _w = &v;
     borrow_mut(v); //~ ERROR cannot borrow
 }
@@ -35,7 +36,7 @@ fn pre_freeze() {
 fn post_freeze() {
     // In this instance, the const alias starts after the borrow.
 
-    let mut v = ~3;
+    let mut v = box 3;
     borrow_mut(v);
     let _w = &v;
 }
diff --git a/src/test/compile-fail/borrowck-loan-blocks-move-cc.rs b/src/test/compile-fail/borrowck-loan-blocks-move-cc.rs
index 0fa2ee5be17..d262bcee983 100644
--- a/src/test/compile-fail/borrowck-loan-blocks-move-cc.rs
+++ b/src/test/compile-fail/borrowck-loan-blocks-move-cc.rs
@@ -15,7 +15,7 @@ fn borrow(v: &int, f: |x: &int|) {
 }
 
 fn box_imm() {
-    let v = ~3;
+    let v = box 3;
     let _w = &v;
     task::spawn(proc() {
         println!("v={}", *v);
@@ -24,7 +24,7 @@ fn box_imm() {
 }
 
 fn box_imm_explicit() {
-    let v = ~3;
+    let v = box 3;
     let _w = &v;
     task::spawn(proc() {
         println!("v={}", *v);
diff --git a/src/test/compile-fail/borrowck-loan-blocks-move.rs b/src/test/compile-fail/borrowck-loan-blocks-move.rs
index b9a79f4f3b1..3c284ede0c8 100644
--- a/src/test/compile-fail/borrowck-loan-blocks-move.rs
+++ b/src/test/compile-fail/borrowck-loan-blocks-move.rs
@@ -8,11 +8,12 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn take(_v: ~int) {
+
+fn take(_v: Box<int>) {
 }
 
 fn box_imm() {
-    let v = ~3;
+    let v = box 3;
     let _w = &v;
     take(v); //~ ERROR cannot move out of `v` because it is borrowed
 }
diff --git a/src/test/compile-fail/borrowck-loan-blocks-mut-uniq.rs b/src/test/compile-fail/borrowck-loan-blocks-mut-uniq.rs
index 6a0d3ef82fb..c11a08b254f 100644
--- a/src/test/compile-fail/borrowck-loan-blocks-mut-uniq.rs
+++ b/src/test/compile-fail/borrowck-loan-blocks-mut-uniq.rs
@@ -13,10 +13,10 @@ fn borrow(v: &int, f: |x: &int|) {
 }
 
 fn box_imm() {
-    let mut v = ~3;
+    let mut v = box 3;
     borrow(v,
            |w| { //~ ERROR cannot borrow `v` as mutable
-            v = ~4;
+            v = box 4;
             assert_eq!(*v, 3);
             assert_eq!(*w, 4);
         })
diff --git a/src/test/compile-fail/borrowck-loan-in-overloaded-op.rs b/src/test/compile-fail/borrowck-loan-in-overloaded-op.rs
index 962b7068546..4a6c20079c1 100644
--- a/src/test/compile-fail/borrowck-loan-in-overloaded-op.rs
+++ b/src/test/compile-fail/borrowck-loan-in-overloaded-op.rs
@@ -8,18 +8,19 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-struct foo(~uint);
+
+struct foo(Box<uint>);
 
 impl Add<foo, foo> for foo {
     fn add(&self, f: &foo) -> foo {
-        let foo(~i) = *self;
-        let foo(~j) = *f;
-        foo(~(i + j))
+        let foo(box i) = *self;
+        let foo(box j) = *f;
+        foo(box() (i + j))
     }
 }
 
 fn main() {
-    let x = foo(~3);
+    let x = foo(box 3);
     let _y = x + {x}; // the `{x}` forces a move to occur
     //~^ ERROR cannot move out of `x`
 }
diff --git a/src/test/compile-fail/borrowck-move-by-capture.rs b/src/test/compile-fail/borrowck-move-by-capture.rs
index f3869e5c9fd..c52924ebdb7 100644
--- a/src/test/compile-fail/borrowck-move-by-capture.rs
+++ b/src/test/compile-fail/borrowck-move-by-capture.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 pub fn main() {
-    let bar = ~3;
+    let bar = box 3;
     let _g = || {
         let _h: proc() -> int = proc() *bar; //~ ERROR cannot move out of captured outer variable
     };
diff --git a/src/test/compile-fail/borrowck-move-error-with-note.rs b/src/test/compile-fail/borrowck-move-error-with-note.rs
index 087e619f213..72101d86960 100644
--- a/src/test/compile-fail/borrowck-move-error-with-note.rs
+++ b/src/test/compile-fail/borrowck-move-error-with-note.rs
@@ -8,14 +8,15 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 enum Foo {
-    Foo1(~u32, ~u32),
-    Foo2(~u32),
+    Foo1(Box<u32>, Box<u32>),
+    Foo2(Box<u32>),
     Foo3,
 }
 
 fn blah() {
-    let f = &Foo1(~1u32, ~2u32);
+    let f = &Foo1(box 1u32, box 2u32);
     match *f {             //~ ERROR cannot move out of
         Foo1(num1,         //~ NOTE attempting to move value to here
              num2) => (),  //~ NOTE and here
@@ -24,7 +25,10 @@ fn blah() {
     }
 }
 
-struct S {f:~str, g:~str}
+struct S {
+    f: ~str,
+    g: ~str
+}
 impl Drop for S {
     fn drop(&mut self) { println!("{}", self.f); }
 }
@@ -40,13 +44,13 @@ fn move_in_match() {
 
 // from issue-8064
 struct A {
-    a: ~int
+    a: Box<int>,
 }
 
 fn free<T>(_: T) {}
 
 fn blah2() {
-    let a = &A { a: ~1 };
+    let a = &A { a: box 1 };
     match a.a {           //~ ERROR cannot move out of
         n => {            //~ NOTE attempting to move value to here
             free(n)
diff --git a/src/test/compile-fail/borrowck-move-from-subpath-of-borrowed-path.rs b/src/test/compile-fail/borrowck-move-from-subpath-of-borrowed-path.rs
index 6106644a263..35106487f34 100644
--- a/src/test/compile-fail/borrowck-move-from-subpath-of-borrowed-path.rs
+++ b/src/test/compile-fail/borrowck-move-from-subpath-of-borrowed-path.rs
@@ -12,7 +12,7 @@
 // borrowed path.
 
 fn main() {
-    let a = ~~2;
+    let a = box box 2;
     let b = &a;
 
     let z = *a; //~ ERROR: cannot move out of `*a` because it is borrowed
diff --git a/src/test/compile-fail/borrowck-move-from-unsafe-ptr.rs b/src/test/compile-fail/borrowck-move-from-unsafe-ptr.rs
index 8f332646bbc..c507b636f15 100644
--- a/src/test/compile-fail/borrowck-move-from-unsafe-ptr.rs
+++ b/src/test/compile-fail/borrowck-move-from-unsafe-ptr.rs
@@ -8,7 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn foo(x: *~int) -> ~int {
+
+fn foo(x: *Box<int>) -> Box<int> {
     let y = *x; //~ ERROR dereference of unsafe pointer requires unsafe function or block
     return y;
 }
diff --git a/src/test/compile-fail/borrowck-move-moved-value-into-closure.rs b/src/test/compile-fail/borrowck-move-moved-value-into-closure.rs
index 53b5d866b81..b385305d74a 100644
--- a/src/test/compile-fail/borrowck-move-moved-value-into-closure.rs
+++ b/src/test/compile-fail/borrowck-move-moved-value-into-closure.rs
@@ -13,7 +13,7 @@ fn call_f(f: proc() -> int) -> int {
 }
 
 fn main() {
-    let t = ~3;
+    let t = box 3;
 
     call_f(proc() { *t + 1 });
     call_f(proc() { *t + 1 }); //~ ERROR capture of moved value
diff --git a/src/test/compile-fail/borrowck-move-subcomponent.rs b/src/test/compile-fail/borrowck-move-subcomponent.rs
index 6940c85e0e6..a29a171e935 100644
--- a/src/test/compile-fail/borrowck-move-subcomponent.rs
+++ b/src/test/compile-fail/borrowck-move-subcomponent.rs
@@ -11,19 +11,15 @@
 // Tests that the borrow checker checks all components of a path when moving
 // out.
 
-#![no_std]
-
-#[lang="sized"]
-pub trait Sized {}
 
 struct S {
-  x : ~int
+  x : Box<int>
 }
 
 fn f<T>(_: T) {}
 
 fn main() {
-  let a : S = S { x : ~1 };
+  let a : S = S { x : box 1 };
   let pb = &a;
   let S { x: ax } = a;  //~ ERROR cannot move out
   f(pb);
diff --git a/src/test/compile-fail/borrowck-no-cycle-in-exchange-heap.rs b/src/test/compile-fail/borrowck-no-cycle-in-exchange-heap.rs
index ed270de51e2..ad90839b4bc 100644
--- a/src/test/compile-fail/borrowck-no-cycle-in-exchange-heap.rs
+++ b/src/test/compile-fail/borrowck-no-cycle-in-exchange-heap.rs
@@ -8,8 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 struct node_ {
-    a: ~cycle
+    a: Box<cycle>
 }
 
 enum cycle {
@@ -17,7 +18,7 @@ enum cycle {
     empty
 }
 fn main() {
-    let mut x = ~node(node_ {a: ~empty});
+    let mut x = box node(node_ {a: box empty});
     // Create a cycle!
     match *x {
       node(ref mut y) => {
diff --git a/src/test/compile-fail/borrowck-object-lifetime.rs b/src/test/compile-fail/borrowck-object-lifetime.rs
index 92b77d8243e..9466a78588c 100644
--- a/src/test/compile-fail/borrowck-object-lifetime.rs
+++ b/src/test/compile-fail/borrowck-object-lifetime.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 trait Foo {
     fn borrowed<'a>(&'a self) -> &'a ();
 }
@@ -16,16 +17,16 @@ fn borrowed_receiver<'a>(x: &'a Foo) -> &'a () {
     x.borrowed()
 }
 
-fn owned_receiver(x: ~Foo) -> &() {
+fn owned_receiver(x: Box<Foo>) -> &() {
     x.borrowed() //~ ERROR `*x` does not live long enough
 }
 
-fn mut_owned_receiver(mut x: ~Foo) {
+fn mut_owned_receiver(mut x: Box<Foo>) {
     let _y = x.borrowed();
     let _z = &mut x; //~ ERROR cannot borrow
 }
 
-fn imm_owned_receiver(mut x: ~Foo) {
+fn imm_owned_receiver(mut x: Box<Foo>) {
     let _y = x.borrowed();
     let _z = &x;
 }
diff --git a/src/test/compile-fail/borrowck-object-mutability.rs b/src/test/compile-fail/borrowck-object-mutability.rs
index d4203dc9916..9b5087bd7e0 100644
--- a/src/test/compile-fail/borrowck-object-mutability.rs
+++ b/src/test/compile-fail/borrowck-object-mutability.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 trait Foo {
     fn borrowed(&self);
     fn borrowed_mut(&mut self);
@@ -23,12 +24,12 @@ fn borrowed_mut_receiver(x: &mut Foo) {
     x.borrowed_mut();
 }
 
-fn owned_receiver(x: ~Foo) {
+fn owned_receiver(x: Box<Foo>) {
     x.borrowed();
     x.borrowed_mut(); //~ ERROR cannot borrow
 }
 
-fn mut_owned_receiver(mut x: ~Foo) {
+fn mut_owned_receiver(mut x: Box<Foo>) {
     x.borrowed();
     x.borrowed_mut();
 }
diff --git a/src/test/compile-fail/borrowck-preserve-box-in-field.rs b/src/test/compile-fail/borrowck-preserve-box-in-field.rs
index ff138451e93..168a331e9fe 100644
--- a/src/test/compile-fail/borrowck-preserve-box-in-field.rs
+++ b/src/test/compile-fail/borrowck-preserve-box-in-field.rs
@@ -14,6 +14,7 @@
 
 #![feature(managed_boxes)]
 
+
 fn borrow(x: &int, f: |x: &int|) {
     let before = *x;
     f(x);
@@ -21,16 +22,16 @@ fn borrow(x: &int, f: |x: &int|) {
     assert_eq!(before, after);
 }
 
-struct F { f: ~int }
+struct F { f: Box<int> }
 
 pub fn main() {
-    let mut x = @F {f: ~3};
+    let mut x = @F {f: box 3};
     borrow(x.f, |b_x| {
     //~^ ERROR cannot borrow `x` as mutable because `*x.f` is also borrowed as immutable
         assert_eq!(*b_x, 3);
         assert_eq!(&(*x.f) as *int, &(*b_x) as *int);
         //~^ NOTE borrow occurs due to use of `x` in closure
-        x = @F {f: ~4};
+        x = @F {f: box 4};
 
         println!("&*b_x = {:p}", &(*b_x));
         assert_eq!(*b_x, 3);
diff --git a/src/test/compile-fail/borrowck-preserve-box-in-uniq.rs b/src/test/compile-fail/borrowck-preserve-box-in-uniq.rs
index b06eb0d6ba2..d79b7e040c7 100644
--- a/src/test/compile-fail/borrowck-preserve-box-in-uniq.rs
+++ b/src/test/compile-fail/borrowck-preserve-box-in-uniq.rs
@@ -14,6 +14,7 @@
 
 #![feature(managed_boxes)]
 
+
 fn borrow(x: &int, f: |x: &int|) {
     let before = *x;
     f(x);
@@ -21,16 +22,16 @@ fn borrow(x: &int, f: |x: &int|) {
     assert_eq!(before, after);
 }
 
-struct F { f: ~int }
+struct F { f: Box<int> }
 
 pub fn main() {
-    let mut x = ~@F{f: ~3};
+    let mut x = box @F{f: box 3};
     borrow(x.f, |b_x| {
     //~^ ERROR cannot borrow `x` as mutable because `*x.f` is also borrowed as immutable
         assert_eq!(*b_x, 3);
         assert_eq!(&(*x.f) as *int, &(*b_x) as *int);
         //~^ NOTE  borrow occurs due to use of `x` in closure
-        *x = @F{f: ~4};
+        *x = @F{f: box 4};
 
         println!("&*b_x = {:p}", &(*b_x));
         assert_eq!(*b_x, 3);
diff --git a/src/test/compile-fail/borrowck-preserve-expl-deref.rs b/src/test/compile-fail/borrowck-preserve-expl-deref.rs
index aeabf6d9f8b..9b7966b0af0 100644
--- a/src/test/compile-fail/borrowck-preserve-expl-deref.rs
+++ b/src/test/compile-fail/borrowck-preserve-expl-deref.rs
@@ -14,6 +14,7 @@
 
 #![feature(managed_boxes)]
 
+
 fn borrow(x: &int, f: |x: &int|) {
     let before = *x;
     f(x);
@@ -21,16 +22,16 @@ fn borrow(x: &int, f: |x: &int|) {
     assert_eq!(before, after);
 }
 
-struct F { f: ~int }
+struct F { f: Box<int> }
 
 pub fn main() {
-    let mut x = @F {f: ~3};
+    let mut x = @F {f: box 3};
     borrow((*x).f, |b_x| {
     //~^ ERROR cannot borrow `x` as mutable because `*x.f` is also borrowed as immutable
         assert_eq!(*b_x, 3);
         assert_eq!(&(*x.f) as *int, &(*b_x) as *int);
         //~^ NOTE borrow occurs due to use of `x` in closure
-        x = @F {f: ~4};
+        x = @F {f: box 4};
 
         println!("&*b_x = {:p}", &(*b_x));
         assert_eq!(*b_x, 3);
diff --git a/src/test/compile-fail/borrowck-struct-update-with-dtor.rs b/src/test/compile-fail/borrowck-struct-update-with-dtor.rs
index 651104d1eda..b5d274a5584 100644
--- a/src/test/compile-fail/borrowck-struct-update-with-dtor.rs
+++ b/src/test/compile-fail/borrowck-struct-update-with-dtor.rs
@@ -13,10 +13,12 @@
 
 // NoCopy
 use NP = std::kinds::marker::NoCopy;
+
+
 struct S { a: int, np: NP }
 impl Drop for S { fn drop(&mut self) { } }
 
-struct T { a: int, mv: ~int }
+struct T { a: int, mv: Box<int> }
 impl Drop for T { fn drop(&mut self) { } }
 
 fn f(s0:S) {
diff --git a/src/test/compile-fail/borrowck-unary-move.rs b/src/test/compile-fail/borrowck-unary-move.rs
index a67a12f9d0f..72941f77210 100644
--- a/src/test/compile-fail/borrowck-unary-move.rs
+++ b/src/test/compile-fail/borrowck-unary-move.rs
@@ -8,13 +8,14 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn foo(x: ~int) -> int {
+
+fn foo(x: Box<int>) -> int {
     let y = &*x;
     free(x); //~ ERROR cannot move out of `x` because it is borrowed
     *y
 }
 
-fn free(_x: ~int) {
+fn free(_x: Box<int>) {
 }
 
 fn main() {
diff --git a/src/test/compile-fail/borrowck-uniq-via-lend.rs b/src/test/compile-fail/borrowck-uniq-via-lend.rs
index c87428cd300..fb03ad61f3d 100644
--- a/src/test/compile-fail/borrowck-uniq-via-lend.rs
+++ b/src/test/compile-fail/borrowck-uniq-via-lend.rs
@@ -8,49 +8,50 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 fn borrow(_v: &int) {}
 
 fn local() {
-    let mut v = ~3;
+    let mut v = box 3;
     borrow(v);
 }
 
 fn local_rec() {
-    struct F { f: ~int }
-    let mut v = F {f: ~3};
+    struct F { f: Box<int> }
+    let mut v = F {f: box 3};
     borrow(v.f);
 }
 
 fn local_recs() {
     struct F { f: G }
     struct G { g: H }
-    struct H { h: ~int }
-    let mut v = F {f: G {g: H {h: ~3}}};
+    struct H { h: Box<int> }
+    let mut v = F {f: G {g: H {h: box 3}}};
     borrow(v.f.g.h);
 }
 
 fn aliased_imm() {
-    let mut v = ~3;
+    let mut v = box 3;
     let _w = &v;
     borrow(v);
 }
 
 fn aliased_mut() {
-    let mut v = ~3;
+    let mut v = box 3;
     let _w = &mut v;
     borrow(v); //~ ERROR cannot borrow `*v`
 }
 
 fn aliased_other() {
-    let mut v = ~3;
-    let mut w = ~4;
+    let mut v = box 3;
+    let mut w = box 4;
     let _x = &mut w;
     borrow(v);
 }
 
 fn aliased_other_reassign() {
-    let mut v = ~3;
-    let mut w = ~4;
+    let mut v = box 3;
+    let mut w = box 4;
     let mut _x = &mut w;
     _x = &mut v;
     borrow(v); //~ ERROR cannot borrow `*v`
diff --git a/src/test/compile-fail/borrowck-vec-pattern-nesting.rs b/src/test/compile-fail/borrowck-vec-pattern-nesting.rs
index 7f0a6c84f8c..f41f74b166f 100644
--- a/src/test/compile-fail/borrowck-vec-pattern-nesting.rs
+++ b/src/test/compile-fail/borrowck-vec-pattern-nesting.rs
@@ -8,28 +8,29 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 fn a() {
-    let mut vec = [~1, ~2, ~3];
+    let mut vec = [box 1, box 2, box 3];
     match vec {
-        [~ref _a, _, _] => {
-            vec[0] = ~4; //~ ERROR cannot assign
+        [box ref _a, _, _] => {
+            vec[0] = box 4; //~ ERROR cannot assign
         }
     }
 }
 
 fn b() {
-    let mut vec = vec!(~1, ~2, ~3);
-    let vec: &mut [~int] = vec.as_mut_slice();
+    let mut vec = vec!(box 1, box 2, box 3);
+    let vec: &mut [Box<int>] = vec.as_mut_slice();
     match vec {
         [.._b] => {
-            vec[0] = ~4; //~ ERROR cannot assign
+            vec[0] = box 4; //~ ERROR cannot assign
         }
     }
 }
 
 fn c() {
-    let mut vec = vec!(~1, ~2, ~3);
-    let vec: &mut [~int] = vec.as_mut_slice();
+    let mut vec = vec!(box 1, box 2, box 3);
+    let vec: &mut [Box<int>] = vec.as_mut_slice();
     match vec {
         [_a,         //~ ERROR cannot move out
          .._b] => {  //~^ NOTE attempting to move value to here
@@ -46,8 +47,8 @@ fn c() {
 }
 
 fn d() {
-    let mut vec = vec!(~1, ~2, ~3);
-    let vec: &mut [~int] = vec.as_mut_slice();
+    let mut vec = vec!(box 1, box 2, box 3);
+    let vec: &mut [Box<int>] = vec.as_mut_slice();
     match vec {
         [.._a,     //~ ERROR cannot move out
          _b] => {} //~ NOTE attempting to move value to here
@@ -57,8 +58,8 @@ fn d() {
 }
 
 fn e() {
-    let mut vec = vec!(~1, ~2, ~3);
-    let vec: &mut [~int] = vec.as_mut_slice();
+    let mut vec = vec!(box 1, box 2, box 3);
+    let vec: &mut [Box<int>] = vec.as_mut_slice();
     match vec {
         [_a, _b, _c] => {}  //~ ERROR cannot move out
         //~^ NOTE attempting to move value to here
diff --git a/src/test/compile-fail/check-static-values-constraints.rs b/src/test/compile-fail/check-static-values-constraints.rs
index a8581534848..6c1e759cc2f 100644
--- a/src/test/compile-fail/check-static-values-constraints.rs
+++ b/src/test/compile-fail/check-static-values-constraints.rs
@@ -94,7 +94,7 @@ static STATIC10: UnsafeStruct = UnsafeStruct;
 
 struct MyOwned;
 
-static STATIC11: ~MyOwned = ~MyOwned;
+static STATIC11: Box<MyOwned> = box MyOwned;
 //~^ ERROR static items are not allowed to have owned pointers
 
 // The following examples test that mutable structs are just forbidden
@@ -109,11 +109,12 @@ static mut STATIC13: SafeStruct = SafeStruct{field1: Variant1, field2: Variant3(
 static mut STATIC14: SafeStruct = SafeStruct{field1: Variant1, field2: Variant4("str".to_owned())};
 //~^ ERROR mutable static items are not allowed to have destructors
 
-static STATIC15: &'static [~MyOwned] = &'static [~MyOwned, ~MyOwned];
+static STATIC15: &'static [Box<MyOwned>] = &'static [box MyOwned, box MyOwned];
 //~^ ERROR static items are not allowed to have owned pointers
 //~^^ ERROR static items are not allowed to have owned pointers
 
-static STATIC16: (&'static ~MyOwned, &'static ~MyOwned) = (&'static ~MyOwned, &'static ~MyOwned);
+static STATIC16: (&'static Box<MyOwned>, &'static Box<MyOwned>) =
+    (&'static box MyOwned, &'static box MyOwned);
 //~^ ERROR static items are not allowed to have owned pointers
 //~^^ ERROR static items are not allowed to have owned pointers
 
@@ -123,10 +124,10 @@ static mut STATIC17: SafeEnum = Variant1;
 static STATIC18: @SafeStruct = @SafeStruct{field1: Variant1, field2: Variant2(0)};
 //~^ ERROR static items are not allowed to have managed pointers
 
-static STATIC19: ~int = box 3;
+static STATIC19: Box<int> = box 3;
 //~^ ERROR static items are not allowed to have owned pointers
 
 pub fn main() {
-    let y = { static x: ~int = ~3; x };
+    let y = { static x: Box<int> = box 3; x };
     //~^ ERROR static items are not allowed to have owned pointers
 }
diff --git a/src/test/compile-fail/class-cast-to-trait.rs b/src/test/compile-fail/class-cast-to-trait.rs
index 506e1cba9fd..c4344db027b 100644
--- a/src/test/compile-fail/class-cast-to-trait.rs
+++ b/src/test/compile-fail/class-cast-to-trait.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 trait noisy {
   fn speak(&self);
 }
@@ -57,6 +58,6 @@ fn cat(in_x : uint, in_y : int, in_name: ~str) -> cat {
 }
 
 fn main() {
-  let nyan: ~noisy = ~cat(0, 2, "nyan".to_owned()) as ~noisy;
+  let nyan: Box<noisy> = box cat(0, 2, "nyan".to_owned()) as Box<noisy>;
   nyan.eat(); //~ ERROR does not implement any method in scope named `eat`
 }
diff --git a/src/test/compile-fail/estr-subtyping.rs b/src/test/compile-fail/estr-subtyping.rs
index 5927ae12f1c..db86b5e092c 100644
--- a/src/test/compile-fail/estr-subtyping.rs
+++ b/src/test/compile-fail/estr-subtyping.rs
@@ -17,7 +17,7 @@ fn has_uniq(x: ~str) {
 }
 
 fn has_slice(x: &str) {
-   wants_uniq(x); //~ ERROR mismatched types: expected `~str` but found `&str` (expected ~-ptr but f
+   wants_uniq(x); //~ ERROR mismatched types: expected `~str` but found `&str` (expected box but f
    wants_slice(x);
 }
 
diff --git a/src/test/compile-fail/immut-function-arguments.rs b/src/test/compile-fail/immut-function-arguments.rs
index 663a50e9e55..71328acdd70 100644
--- a/src/test/compile-fail/immut-function-arguments.rs
+++ b/src/test/compile-fail/immut-function-arguments.rs
@@ -8,12 +8,13 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn f(y: ~int) {
+
+fn f(y: Box<int>) {
     *y = 5; //~ ERROR cannot assign
 }
 
 fn g() {
-    let _frob: |~int| = |q| { *q = 2; }; //~ ERROR cannot assign
+    let _frob: |Box<int>| = |q| { *q = 2; }; //~ ERROR cannot assign
 
 }
 
diff --git a/src/test/compile-fail/infinite-autoderef.rs b/src/test/compile-fail/infinite-autoderef.rs
index ddef459453e..b41797d0042 100644
--- a/src/test/compile-fail/infinite-autoderef.rs
+++ b/src/test/compile-fail/infinite-autoderef.rs
@@ -23,7 +23,7 @@ impl Deref<Foo> for Foo {
 pub fn main() {
     let mut x;
     loop {
-        x = ~x;
+        x = box x;
         x.foo;
         x.bar();
     }
diff --git a/src/test/compile-fail/inherit-struct1.rs b/src/test/compile-fail/inherit-struct1.rs
index 00ea4b7783b..47f2b291187 100644
--- a/src/test/compile-fail/inherit-struct1.rs
+++ b/src/test/compile-fail/inherit-struct1.rs
@@ -11,7 +11,8 @@
 // Test struct inheritance.
 #![feature(struct_inherit)]
 
-struct S6 : ~S2; //~ ERROR not a struct
+
+struct S6 : int; //~ ERROR super-struct could not be resolved
 
 pub fn main() {
 }
diff --git a/src/test/compile-fail/issue-10398.rs b/src/test/compile-fail/issue-10398.rs
index a58c88737b6..97642377ba8 100644
--- a/src/test/compile-fail/issue-10398.rs
+++ b/src/test/compile-fail/issue-10398.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 fn main() {
-    let x = ~1;
+    let x = box 1;
     let f: proc() = proc() {
         let _a = x;
         drop(x);
diff --git a/src/test/compile-fail/issue-11192.rs b/src/test/compile-fail/issue-11192.rs
index f1da3032890..e7fa8300bcb 100644
--- a/src/test/compile-fail/issue-11192.rs
+++ b/src/test/compile-fail/issue-11192.rs
@@ -19,10 +19,10 @@ impl Drop for Foo {
 }
 
 fn main() {
-    let mut ptr = ~Foo { x: 0 };
+    let mut ptr = box Foo { x: 0 };
     let test = |foo: &Foo| {
         println!("access {}", foo.x);
-        ptr = ~Foo { x: ptr.x + 1 };
+        ptr = box Foo { x: ptr.x + 1 };
         println!("access {}", foo.x);
     };
     test(ptr);
diff --git a/src/test/compile-fail/issue-11515.rs b/src/test/compile-fail/issue-11515.rs
index 52288a9ce02..4d520b570b7 100644
--- a/src/test/compile-fail/issue-11515.rs
+++ b/src/test/compile-fail/issue-11515.rs
@@ -13,6 +13,6 @@ struct Test<'s> {
 }
 
 fn main() {
-    let test = ~Test { func: proc() {} };
+    let test = box Test { func: proc() {} };
     //~^ ERROR: expected `||` but found `proc()`
 }
diff --git a/src/test/compile-fail/issue-11925.rs b/src/test/compile-fail/issue-11925.rs
index 0b8eaa5b831..a8d2c7509ce 100644
--- a/src/test/compile-fail/issue-11925.rs
+++ b/src/test/compile-fail/issue-11925.rs
@@ -10,7 +10,7 @@
 
 fn main() {
     let r = {
-        let x = ~42;
+        let x = box 42;
         let f = proc() &x; //~ ERROR: `x` does not live long enough
         f()
     };
diff --git a/src/test/compile-fail/issue-2063.rs b/src/test/compile-fail/issue-2063.rs
index b6425dac3c1..4a6219aafd0 100644
--- a/src/test/compile-fail/issue-2063.rs
+++ b/src/test/compile-fail/issue-2063.rs
@@ -11,7 +11,9 @@
 // test that autoderef of a type like this does not
 // cause compiler to loop.  Note that no instances
 // of such a type could ever be constructed.
-struct t(~t); //~ ERROR this type cannot be instantiated
+
+
+struct t(Box<t>); //~ ERROR this type cannot be instantiated
 
 trait to_str_2 {
     fn my_to_str() -> ~str;
diff --git a/src/test/compile-fail/issue-3601.rs b/src/test/compile-fail/issue-3601.rs
index c37c5a3e5af..6ca4e22576e 100644
--- a/src/test/compile-fail/issue-3601.rs
+++ b/src/test/compile-fail/issue-3601.rs
@@ -8,12 +8,13 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 struct HTMLImageData {
     image: Option<~str>
 }
 
 struct ElementData {
-    kind: ~ElementKind
+    kind: Box<ElementKind>
 }
 
 enum ElementKind {
@@ -25,17 +26,17 @@ enum NodeKind {
 }
 
 struct NodeData {
-    kind: ~NodeKind
+    kind: Box<NodeKind>,
 }
 
 fn main() {
     let mut id = HTMLImageData { image: None };
-    let ed = ElementData { kind: ~HTMLImageElement(id) };
-    let n = NodeData {kind : ~Element(ed)};
+    let ed = ElementData { kind: box HTMLImageElement(id) };
+    let n = NodeData {kind : box Element(ed)};
     // n.b. span could be better
     match n.kind {
-        ~Element(ed) => match ed.kind { //~ ERROR non-exhaustive patterns
-            ~HTMLImageElement(ref d) if d.image.is_some() => { true }
+        box Element(ed) => match ed.kind { //~ ERROR non-exhaustive patterns
+            box HTMLImageElement(ref d) if d.image.is_some() => { true }
         },
         _ => fail!("WAT") //~ ERROR unreachable pattern
     };
diff --git a/src/test/compile-fail/issue-3763.rs b/src/test/compile-fail/issue-3763.rs
index 8eed8aa8644..657d9c8f17e 100644
--- a/src/test/compile-fail/issue-3763.rs
+++ b/src/test/compile-fail/issue-3763.rs
@@ -26,12 +26,12 @@ fn main() {
     let my_struct = my_mod::MyStruct();
     let _woohoo = (&my_struct).priv_field;
     //~^ ERROR field `priv_field` of struct `my_mod::MyStruct` is private
-    let _woohoo = (~my_struct).priv_field;
+    let _woohoo = (box my_struct).priv_field;
     //~^ ERROR field `priv_field` of struct `my_mod::MyStruct` is private
     let _woohoo = (@my_struct).priv_field;
     //~^ ERROR field `priv_field` of struct `my_mod::MyStruct` is private
     (&my_struct).happyfun();               //~ ERROR method `happyfun` is private
-    (~my_struct).happyfun();               //~ ERROR method `happyfun` is private
+    (box my_struct).happyfun();            //~ ERROR method `happyfun` is private
     (@my_struct).happyfun();               //~ ERROR method `happyfun` is private
     let nope = my_struct.priv_field;
     //~^ ERROR field `priv_field` of struct `my_mod::MyStruct` is private
diff --git a/src/test/compile-fail/issue-4972.rs b/src/test/compile-fail/issue-4972.rs
index 8d281a0b174..ffac6b499f4 100644
--- a/src/test/compile-fail/issue-4972.rs
+++ b/src/test/compile-fail/issue-4972.rs
@@ -8,15 +8,16 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 trait MyTrait { }
 
 pub enum TraitWrapper {
-    A(~MyTrait),
+    A(Box<MyTrait>),
 }
 
 fn get_tw_map<'lt>(tw: &'lt TraitWrapper) -> &'lt MyTrait {
     match *tw {
-        A(~ref map) => map, //~ ERROR found a `~`-box pattern
+        A(box ref map) => map, //~ ERROR found a box pattern
     }
 }
 
diff --git a/src/test/compile-fail/issue-5100.rs b/src/test/compile-fail/issue-5100.rs
index b7c440d30b3..6734a546be5 100644
--- a/src/test/compile-fail/issue-5100.rs
+++ b/src/test/compile-fail/issue-5100.rs
@@ -23,8 +23,8 @@ fn main() {
     }
 
     match (true, false) {
-        ~(true, false) => ()
-        //~^ ERROR mismatched types: expected `(bool,bool)` but found a `~`-box pattern
+        box (true, false) => ()
+        //~^ ERROR mismatched types: expected `(bool,bool)` but found a box pattern
     }
 
     match (true, false) {
diff --git a/src/test/compile-fail/issue-5439.rs b/src/test/compile-fail/issue-5439.rs
index 03fe86cb879..55e3459a589 100644
--- a/src/test/compile-fail/issue-5439.rs
+++ b/src/test/compile-fail/issue-5439.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 struct Foo {
     foo: int,
 }
@@ -17,8 +18,8 @@ struct Bar {
 }
 
 impl Bar {
-    fn make_foo (&self, i: int) -> ~Foo {
-        return ~Foo { nonexistent: self, foo: i }; //~ ERROR: no field named
+    fn make_foo (&self, i: int) -> Box<Foo> {
+        return box Foo { nonexistent: self, foo: i }; //~ ERROR: no field named
     }
 }
 
diff --git a/src/test/compile-fail/issue-6801.rs b/src/test/compile-fail/issue-6801.rs
index a80d4b72192..5925f686939 100644
--- a/src/test/compile-fail/issue-6801.rs
+++ b/src/test/compile-fail/issue-6801.rs
@@ -12,7 +12,8 @@
 // transferring ownership of the owned box before invoking the stack
 // closure results in a crash.
 
-fn twice(x: ~uint) -> uint {
+
+fn twice(x: Box<uint>) -> uint {
      *x * 2
 }
 
@@ -21,7 +22,7 @@ fn invoke(f: || -> uint) {
 }
 
 fn main() {
-      let x  : ~uint         = ~9;
+      let x  : Box<uint>  = box 9;
       let sq : || -> uint =  || { *x * *x };
 
       twice(x); //~ ERROR: cannot move out of
diff --git a/src/test/compile-fail/issue-7013.rs b/src/test/compile-fail/issue-7013.rs
index 6a7f01e6767..1bc4e076553 100644
--- a/src/test/compile-fail/issue-7013.rs
+++ b/src/test/compile-fail/issue-7013.rs
@@ -8,35 +8,30 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::rc::Rc;
 use std::cell::RefCell;
+use std::rc::Rc;
 
-trait Foo
-{
+trait Foo {
     fn set(&mut self, v: Rc<RefCell<A>>);
 }
 
-struct B
-{
+struct B {
     v: Option<Rc<RefCell<A>>>
 }
 
-impl Foo for B
-{
+impl Foo for B {
     fn set(&mut self, v: Rc<RefCell<A>>)
     {
         self.v = Some(v);
     }
 }
 
-struct A
-{
-    v: ~Foo:Send,
+struct A {
+    v: Box<Foo:Send>,
 }
 
-fn main()
-{
-    let a = A {v: ~B{v: None} as ~Foo:Send};
+fn main() {
+    let a = A {v: box B{v: None} as Box<Foo:Send>};
     //~^ ERROR cannot pack type `~B`, which does not fulfill `Send`
     let v = Rc::new(RefCell::new(a));
     let w = v.clone();
diff --git a/src/test/compile-fail/issue-8727.rs b/src/test/compile-fail/issue-8727.rs
index 9d7edefbf02..e2790eb7b39 100644
--- a/src/test/compile-fail/issue-8727.rs
+++ b/src/test/compile-fail/issue-8727.rs
@@ -11,7 +11,8 @@
 // Verify the compiler fails with an error on infinite function
 // recursions.
 
-struct Data(~Option<Data>);
+
+struct Data(Box<Option<Data>>);
 
 fn generic<T>( _ : Vec<(Data,T)> ) {
     //~^ ERROR reached the recursion limit during monomorphization
diff --git a/src/test/compile-fail/kindck-copy.rs b/src/test/compile-fail/kindck-copy.rs
index d4010346998..694b0f1dbe2 100644
--- a/src/test/compile-fail/kindck-copy.rs
+++ b/src/test/compile-fail/kindck-copy.rs
@@ -23,7 +23,7 @@ struct MyStruct {
 }
 
 struct MyNoncopyStruct {
-    x: ~int,
+    x: Box<int>,
 }
 
 fn test<'a,T,U:Copy>(_: &'a int) {
@@ -38,10 +38,10 @@ fn test<'a,T,U:Copy>(_: &'a int) {
     assert_copy::<&'a mut int>();  //~ ERROR does not fulfill
 
     // ~ pointers are not ok
-    assert_copy::<~int>();   //~ ERROR does not fulfill
+    assert_copy::<Box<int>>();   //~ ERROR does not fulfill
     assert_copy::<~str>();   //~ ERROR does not fulfill
     assert_copy::<Vec<int> >(); //~ ERROR does not fulfill
-    assert_copy::<~&'a mut int>(); //~ ERROR does not fulfill
+    assert_copy::<Box<&'a mut int>>(); //~ ERROR does not fulfill
 
     // borrowed object types are generally ok
     assert_copy::<&'a Dummy>();
@@ -49,8 +49,8 @@ fn test<'a,T,U:Copy>(_: &'a int) {
     assert_copy::<&'static Dummy:Copy>();
 
     // owned object types are not ok
-    assert_copy::<~Dummy>(); //~ ERROR does not fulfill
-    assert_copy::<~Dummy:Copy>(); //~ ERROR does not fulfill
+    assert_copy::<Box<Dummy>>(); //~ ERROR does not fulfill
+    assert_copy::<Box<Dummy:Copy>>(); //~ ERROR does not fulfill
 
     // mutable object types are not ok
     assert_copy::<&'a mut Dummy:Copy>();  //~ ERROR does not fulfill
diff --git a/src/test/compile-fail/kindck-owned-trait-contains.rs b/src/test/compile-fail/kindck-owned-trait-contains.rs
index e2005cbae91..3f6c622dd0d 100644
--- a/src/test/compile-fail/kindck-owned-trait-contains.rs
+++ b/src/test/compile-fail/kindck-owned-trait-contains.rs
@@ -8,14 +8,15 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 trait Repeat<A> { fn get(&self) -> A; }
 
 impl<A:Clone> Repeat<A> for A {
     fn get(&self) -> A { self.clone() }
 }
 
-fn repeater<A:Clone>(v: A) -> ~Repeat<A>: {
-    ~v as ~Repeat<A>: // No
+fn repeater<A:Clone>(v: A) -> Box<Repeat<A>:> {
+    box v as Box<Repeat<A>:> // No
 }
 
 fn main() {
diff --git a/src/test/compile-fail/kindck-send.rs b/src/test/compile-fail/kindck-send.rs
index cdf24257ce7..518e97515e7 100644
--- a/src/test/compile-fail/kindck-send.rs
+++ b/src/test/compile-fail/kindck-send.rs
@@ -28,28 +28,28 @@ fn test<'a,T,U:Send>(_: &'a int) {
     assert_send::<&'a str>(); //~ ERROR does not fulfill `Send`
     assert_send::<&'a [int]>(); //~ ERROR does not fulfill `Send`
 
-    // ~ pointers are ok
-    assert_send::<~int>();
+    // boxes are ok
+    assert_send::<Box<int>>();
     assert_send::<~str>();
     assert_send::<Vec<int> >();
 
     // but not if they own a bad thing
-    assert_send::<~&'a int>(); //~ ERROR does not fulfill `Send`
+    assert_send::<Box<&'a int>>(); //~ ERROR does not fulfill `Send`
 
     // careful with object types, who knows what they close over...
     assert_send::<&'static Dummy>(); //~ ERROR does not fulfill `Send`
     assert_send::<&'a Dummy>(); //~ ERROR does not fulfill `Send`
     assert_send::<&'a Dummy:Send>(); //~ ERROR does not fulfill `Send`
-    assert_send::<~Dummy:>(); //~ ERROR does not fulfill `Send`
+    assert_send::<Box<Dummy:>>(); //~ ERROR does not fulfill `Send`
 
     // ...unless they are properly bounded
     assert_send::<&'static Dummy:Send>();
-    assert_send::<~Dummy:Send>();
+    assert_send::<Box<Dummy:Send>>();
 
     // but closure and object types can have lifetime bounds which make
     // them not ok (FIXME #5121)
     // assert_send::<proc:'a()>(); // ERROR does not fulfill `Send`
-    // assert_send::<~Dummy:'a>(); // ERROR does not fulfill `Send`
+    // assert_send::<Box<Dummy:'a>>(); // ERROR does not fulfill `Send`
 
     // unsafe ptrs are ok unless they point at unsendable things
     assert_send::<*int>();
diff --git a/src/test/compile-fail/lint-allocation.rs b/src/test/compile-fail/lint-allocation.rs
index 46199fa0280..c898107f5e3 100644
--- a/src/test/compile-fail/lint-allocation.rs
+++ b/src/test/compile-fail/lint-allocation.rs
@@ -14,6 +14,6 @@ fn f(_: &int) {}
 fn g(_: &mut int) {}
 
 fn main() {
-    f(~1); //~ ERROR unnecessary allocation, use & instead
-    g(~1); //~ ERROR unnecessary allocation, use &mut instead
+    f(box 1); //~ ERROR unnecessary allocation, use & instead
+    g(box 1); //~ ERROR unnecessary allocation, use &mut instead
 }
diff --git a/src/test/compile-fail/lint-dead-code-1.rs b/src/test/compile-fail/lint-dead-code-1.rs
index bbcc59f0d6c..10734f1f243 100644
--- a/src/test/compile-fail/lint-dead-code-1.rs
+++ b/src/test/compile-fail/lint-dead-code-1.rs
@@ -36,7 +36,7 @@ pub static used_static2: int = used_static;
 static USED_STATIC: int = 0;
 static STATIC_USED_IN_ENUM_DISCRIMINANT: uint = 10;
 
-pub type typ = ~UsedStruct4;
+pub type typ = *UsedStruct4;
 pub struct PubStruct();
 struct PrivStruct; //~ ERROR: code is never used
 struct UsedStruct1 { x: int }
@@ -57,7 +57,7 @@ pub struct PubStruct2 {
 }
 
 pub enum pub_enum { foo1, bar1 }
-pub enum pub_enum2 { a(~StructUsedInEnum) }
+pub enum pub_enum2 { a(*StructUsedInEnum) }
 pub enum pub_enum3 { Foo = STATIC_USED_IN_ENUM_DISCRIMINANT }
 enum priv_enum { foo2, bar2 } //~ ERROR: code is never used
 enum used_enum { foo3, bar3 }
diff --git a/src/test/compile-fail/lint-heap-memory.rs b/src/test/compile-fail/lint-heap-memory.rs
index 5f2987c6cfb..eaa1819bd53 100644
--- a/src/test/compile-fail/lint-heap-memory.rs
+++ b/src/test/compile-fail/lint-heap-memory.rs
@@ -13,19 +13,20 @@
 #![allow(dead_code)]
 #![allow(deprecated_owned_vector)]
 
+
 struct Foo {
     x: @int //~ ERROR type uses managed
 }
 
-struct Bar { x: ~int } //~ ERROR type uses owned
+struct Bar { x: Box<int> } //~ ERROR type uses owned
 
 fn main() {
-    let _x : Bar = Bar {x : ~10}; //~ ERROR type uses owned
+    let _x : Bar = Bar {x : box 10}; //~ ERROR type uses owned
 
     @2; //~ ERROR type uses managed
 
-    ~2; //~ ERROR type uses owned
-    fn g(_: ~Clone) {} //~ ERROR type uses owned
+    box 2; //~ ERROR type uses owned
+    fn g(_: Box<Clone>) {} //~ ERROR type uses owned
     "".to_owned(); //~ ERROR type uses owned
     proc() {}; //~ ERROR type uses owned
 }
diff --git a/src/test/compile-fail/lint-owned-heap-memory.rs b/src/test/compile-fail/lint-owned-heap-memory.rs
index 859dd127b97..c9688ad49d7 100644
--- a/src/test/compile-fail/lint-owned-heap-memory.rs
+++ b/src/test/compile-fail/lint-owned-heap-memory.rs
@@ -10,11 +10,12 @@
 
 #![forbid(owned_heap_memory)]
 
+
 struct Foo {
-    x: ~int //~ ERROR type uses owned
+    x: Box<int> //~ ERROR type uses owned
 }
 
 fn main() {
-    let _x : Foo = Foo {x : ~10};
+    let _x : Foo = Foo {x : box 10};
     //~^ ERROR type uses owned
 }
diff --git a/src/test/compile-fail/liveness-move-call-arg.rs b/src/test/compile-fail/liveness-move-call-arg.rs
index ae1c086b340..b9ad1c0fb65 100644
--- a/src/test/compile-fail/liveness-move-call-arg.rs
+++ b/src/test/compile-fail/liveness-move-call-arg.rs
@@ -8,11 +8,12 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn take(_x: ~int) {}
+
+fn take(_x: Box<int>) {}
 
 fn main() {
 
-    let x: ~int = ~25;
+    let x: Box<int> = box 25;
     loop {
         take(x); //~ ERROR use of moved value: `x`
     }
diff --git a/src/test/compile-fail/liveness-move-in-loop.rs b/src/test/compile-fail/liveness-move-in-loop.rs
index a64d7578af3..018b0aaecfd 100644
--- a/src/test/compile-fail/liveness-move-in-loop.rs
+++ b/src/test/compile-fail/liveness-move-in-loop.rs
@@ -8,9 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 fn main() {
-    let y: ~int = ~42;
-    let mut x: ~int;
+    let y: Box<int> = box 42;
+    let mut x: Box<int>;
     loop {
         println!("{:?}", y);
         loop {
diff --git a/src/test/compile-fail/liveness-move-in-while.rs b/src/test/compile-fail/liveness-move-in-while.rs
index 8aa85c03ad4..e32d8a78585 100644
--- a/src/test/compile-fail/liveness-move-in-while.rs
+++ b/src/test/compile-fail/liveness-move-in-while.rs
@@ -8,10 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn main() {
 
-    let y: ~int = ~42;
-    let mut x: ~int;
+fn main() {
+    let y: Box<int> = box 42;
+    let mut x: Box<int>;
     loop {
         println!("{:?}", y); //~ ERROR use of moved value: `y`
         while true { while true { while true { x = y; x.clone(); } } }
diff --git a/src/test/compile-fail/liveness-use-after-move.rs b/src/test/compile-fail/liveness-use-after-move.rs
index eccb3784325..f2b8976c61b 100644
--- a/src/test/compile-fail/liveness-use-after-move.rs
+++ b/src/test/compile-fail/liveness-use-after-move.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 fn main() {
-    let x = ~5;
+    let x = box 5;
     let y = x;
     println!("{:?}", *x); //~ ERROR use of moved value: `x`
     y.clone();
diff --git a/src/test/compile-fail/liveness-use-after-send.rs b/src/test/compile-fail/liveness-use-after-send.rs
index 8747d055ff9..2716d476c3a 100644
--- a/src/test/compile-fail/liveness-use-after-send.rs
+++ b/src/test/compile-fail/liveness-use-after-send.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 fn send<T:Send>(ch: _chan<T>, data: T) {
     println!("{:?}", ch);
     println!("{:?}", data);
@@ -18,7 +19,7 @@ struct _chan<T>(int);
 
 // Tests that "log(debug, message);" is flagged as using
 // message after the send deinitializes it
-fn test00_start(ch: _chan<~int>, message: ~int, _count: ~int) {
+fn test00_start(ch: _chan<Box<int>>, message: Box<int>, _count: Box<int>) {
     send(ch, message);
     println!("{:?}", message); //~ ERROR use of moved value: `message`
 }
diff --git a/src/test/compile-fail/map-types.rs b/src/test/compile-fail/map-types.rs
index bd10c6ad8c3..eda4deba752 100644
--- a/src/test/compile-fail/map-types.rs
+++ b/src/test/compile-fail/map-types.rs
@@ -15,9 +15,9 @@ use collections::HashMap;
 // Test that trait types printed in error msgs include the type arguments.
 
 fn main() {
-    let x: ~HashMap<~str, ~str> = ~HashMap::new();
-    let x: ~Map<~str, ~str> = x;
-    let y: ~Map<uint, ~str> = ~x;
+    let x: Box<HashMap<~str, ~str>> = box HashMap::new();
+    let x: Box<Map<~str, ~str>> = x;
+    let y: Box<Map<uint, ~str>> = box x;
     //~^ ERROR failed to find an implementation of trait std::container::Map<uint,~str>
     //         for ~std::container::Map<~str,~str>:Send
 }
diff --git a/src/test/compile-fail/moves-based-on-type-block-bad.rs b/src/test/compile-fail/moves-based-on-type-block-bad.rs
index 4ec0831c588..73323def28d 100644
--- a/src/test/compile-fail/moves-based-on-type-block-bad.rs
+++ b/src/test/compile-fail/moves-based-on-type-block-bad.rs
@@ -8,13 +8,14 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 struct S {
-    x: ~E
+    x: Box<E>
 }
 
 enum E {
-    Foo(~S),
-    Bar(~int),
+    Foo(Box<S>),
+    Bar(Box<int>),
     Baz
 }
 
@@ -23,13 +24,13 @@ fn f(s: &S, g: |&S|) {
 }
 
 fn main() {
-    let s = S { x: ~Bar(~42) };
+    let s = S { x: box Bar(box 42) };
     loop {
         f(&s, |hellothere| {
             match hellothere.x { //~ ERROR cannot move out
-                ~Foo(_) => {}
-                ~Bar(x) => println!("{}", x.to_str()), //~ NOTE attempting to move value to here
-                ~Baz => {}
+                box Foo(_) => {}
+                box Bar(x) => println!("{}", x.to_str()), //~ NOTE attempting to move value to here
+                box Baz => {}
             }
         })
     }
diff --git a/src/test/compile-fail/moves-based-on-type-cyclic-types-issue-4821.rs b/src/test/compile-fail/moves-based-on-type-cyclic-types-issue-4821.rs
index cf82cf087a3..805c82f03f9 100644
--- a/src/test/compile-fail/moves-based-on-type-cyclic-types-issue-4821.rs
+++ b/src/test/compile-fail/moves-based-on-type-cyclic-types-issue-4821.rs
@@ -12,9 +12,10 @@
 // temporary kinds wound up being stored in a cache and used later.
 // See middle::ty::type_contents() for more information.
 
-struct List { key: int, next: Option<~List> }
 
-fn foo(node: ~List) -> int {
+struct List { key: int, next: Option<Box<List>> }
+
+fn foo(node: Box<List>) -> int {
     let r = match node.next {
         Some(right) => consume(right),
         None => 0
@@ -22,7 +23,7 @@ fn foo(node: ~List) -> int {
     consume(node) + r //~ ERROR use of partially moved value: `node`
 }
 
-fn consume(v: ~List) -> int {
+fn consume(v: Box<List>) -> int {
     v.key
 }
 
diff --git a/src/test/compile-fail/moves-based-on-type-move-out-of-closure-env-issue-1965.rs b/src/test/compile-fail/moves-based-on-type-move-out-of-closure-env-issue-1965.rs
index ac52f10ba70..f9614574abd 100644
--- a/src/test/compile-fail/moves-based-on-type-move-out-of-closure-env-issue-1965.rs
+++ b/src/test/compile-fail/moves-based-on-type-move-out-of-closure-env-issue-1965.rs
@@ -10,9 +10,9 @@
 
 use std::uint;
 
-fn test(_x: ~uint) {}
+fn test(_x: Box<uint>) {}
 
 fn main() {
-    let i = ~3;
+    let i = box 3;
     let _f = || test(i); //~ ERROR cannot move out
 }
diff --git a/src/test/compile-fail/moves-based-on-type-tuple.rs b/src/test/compile-fail/moves-based-on-type-tuple.rs
index 6d5bb638be6..85c435ef0db 100644
--- a/src/test/compile-fail/moves-based-on-type-tuple.rs
+++ b/src/test/compile-fail/moves-based-on-type-tuple.rs
@@ -8,7 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn dup(x: ~int) -> ~(~int,~int) { ~(x, x) } //~ ERROR use of moved value
+
+fn dup(x: Box<int>) -> Box<(Box<int>,Box<int>)> { box() (x, x) } //~ ERROR use of moved value
 fn main() {
-    dup(~3);
+    dup(box 3);
 }
diff --git a/src/test/compile-fail/moves-sru-moved-field.rs b/src/test/compile-fail/moves-sru-moved-field.rs
index 3306d19186c..6f8353c6164 100644
--- a/src/test/compile-fail/moves-sru-moved-field.rs
+++ b/src/test/compile-fail/moves-sru-moved-field.rs
@@ -8,18 +8,19 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 type Noncopyable = proc();
 
 struct Foo {
     copied: int,
-    moved: ~int,
+    moved: Box<int>,
     noncopyable: Noncopyable
 }
 
 fn test0(f: Foo, g: Noncopyable, h: Noncopyable) {
     // just copy implicitly copyable fields from `f`, no moves:
-    let _b = Foo {moved: ~1, noncopyable: g, ..f};
-    let _c = Foo {moved: ~2, noncopyable: h, ..f};
+    let _b = Foo {moved: box 1, noncopyable: g, ..f};
+    let _c = Foo {moved: box 2, noncopyable: h, ..f};
 }
 
 fn test1(f: Foo, g: Noncopyable, h: Noncopyable) {
@@ -30,7 +31,7 @@ fn test1(f: Foo, g: Noncopyable, h: Noncopyable) {
 
 fn test2(f: Foo, g: Noncopyable) {
     // move non-copyable field
-    let _b = Foo {copied: 22, moved: ~23, ..f};
+    let _b = Foo {copied: 22, moved: box 23, ..f};
     let _c = Foo {noncopyable: g, ..f}; //~ ERROR use of partially moved value: `f`
 }
 
diff --git a/src/test/compile-fail/new-box-syntax-bad.rs b/src/test/compile-fail/new-box-syntax-bad.rs
index 4b00334899d..543902a7a55 100644
--- a/src/test/compile-fail/new-box-syntax-bad.rs
+++ b/src/test/compile-fail/new-box-syntax-bad.rs
@@ -14,11 +14,11 @@
 // Tests that the new `box` syntax works with unique pointers and GC pointers.
 
 use std::gc::Gc;
-use std::owned::HEAP;
+use std::owned::{Box, HEAP};
 
 pub fn main() {
     let x: Gc<int> = box(HEAP) 2;  //~ ERROR mismatched types
     let y: Gc<int> = box(HEAP)(1 + 2);  //~ ERROR mismatched types
-    let z: ~int = box(GC)(4 + 5);   //~ ERROR mismatched types
+    let z: Box<int> = box(GC)(4 + 5);   //~ ERROR mismatched types
 }
 
diff --git a/src/test/compile-fail/object-does-not-impl-trait.rs b/src/test/compile-fail/object-does-not-impl-trait.rs
index 95f92380816..17083933afa 100644
--- a/src/test/compile-fail/object-does-not-impl-trait.rs
+++ b/src/test/compile-fail/object-does-not-impl-trait.rs
@@ -8,10 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// Test that an object type `~Foo` is not considered to implement the
+// Test that an object type `Box<Foo>` is not considered to implement the
 // trait `Foo`. Issue #5087.
 
+
 trait Foo {}
 fn take_foo<F:Foo>(f: F) {}
-fn take_object(f: ~Foo) { take_foo(f); } //~ ERROR failed to find an implementation of trait
+fn take_object(f: Box<Foo>) { take_foo(f); } //~ ERROR failed to find an implementation of trait
 fn main() {}
diff --git a/src/test/compile-fail/object-pointer-types.rs b/src/test/compile-fail/object-pointer-types.rs
index ab2aa928c26..8868ddd4dfa 100644
--- a/src/test/compile-fail/object-pointer-types.rs
+++ b/src/test/compile-fail/object-pointer-types.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 trait Foo {
     fn borrowed(&self);
     fn borrowed_mut(&mut self);
@@ -27,7 +28,7 @@ fn borrowed_mut_receiver(x: &mut Foo) {
     x.owned(); //~ ERROR does not implement any method
 }
 
-fn owned_receiver(x: ~Foo) {
+fn owned_receiver(x: Box<Foo>) {
     x.borrowed();
     x.borrowed_mut(); // See [1]
     x.managed();  //~ ERROR does not implement any method
diff --git a/src/test/compile-fail/owned-ptr-static-bound.rs b/src/test/compile-fail/owned-ptr-static-bound.rs
index 508633d2941..48f04c33494 100644
--- a/src/test/compile-fail/owned-ptr-static-bound.rs
+++ b/src/test/compile-fail/owned-ptr-static-bound.rs
@@ -8,22 +8,23 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 trait A<T> {}
 struct B<'a, T>(&'a A<T>);
 
 trait X {}
 impl<'a, T> X for B<'a, T> {}
 
-fn f<'a, T, U>(v: ~A<T>) -> ~X: {
-    ~B(v) as ~X: //~ ERROR value may contain references; add `'static` bound to `T`
+fn f<'a, T, U>(v: Box<A<T>>) -> Box<X:> {
+    box B(v) as Box<X:> //~ ERROR value may contain references; add `'static` bound to `T`
 }
 
-fn g<'a, T, U>(v: ~A<U>) -> ~X: {
-    ~B(v) as ~X: //~ ERROR value may contain references; add `'static` bound to `U`
+fn g<'a, T, U>(v: Box<A<U>>) -> Box<X:> {
+    box B(v) as Box<X:> //~ ERROR value may contain references; add `'static` bound to `U`
 }
 
-fn h<'a, T: 'static>(v: ~A<T>) -> ~X: {
-    ~B(v) as ~X: // ok
+fn h<'a, T: 'static>(v: Box<A<T>>) -> Box<X:> {
+    box B(v) as Box<X:> // ok
 }
 
 fn main() {}
diff --git a/src/test/compile-fail/pinned-deep-copy.rs b/src/test/compile-fail/pinned-deep-copy.rs
index 0589d58a4c2..49f2f35d29d 100644
--- a/src/test/compile-fail/pinned-deep-copy.rs
+++ b/src/test/compile-fail/pinned-deep-copy.rs
@@ -39,7 +39,7 @@ fn main() {
     let i = @Cell::new(0);
     {
         // Can't do this copy
-        let x = ~~~A {y: r(i)};
+        let x = box box box A {y: r(i)};
         let _z = x.clone(); //~ ERROR failed to find an implementation
         println!("{:?}", x);
     }
diff --git a/src/test/compile-fail/privacy-ns1.rs b/src/test/compile-fail/privacy-ns1.rs
index cb11a50055f..b7eee206b40 100644
--- a/src/test/compile-fail/privacy-ns1.rs
+++ b/src/test/compile-fail/privacy-ns1.rs
@@ -15,6 +15,7 @@
 #![allow(dead_code)]
 #![allow(unused_imports)]
 
+
 // public type, private value
 pub mod foo1 {
     pub trait Bar {
@@ -42,7 +43,7 @@ pub mod foo2 {
 fn test_glob2() {
     use foo2::*;
 
-    let _x: ~Bar;  //~ ERROR use of undeclared type name `Bar`
+    let _x: Box<Bar>;  //~ ERROR use of undeclared type name `Bar`
 }
 
 // neither public
@@ -58,7 +59,7 @@ fn test_glob3() {
     use foo3::*;
 
     Bar();  //~ ERROR unresolved name `Bar`.
-    let _x: ~Bar;  //~ ERROR  use of undeclared type name `Bar`
+    let _x: Box<Bar>;  //~ ERROR  use of undeclared type name `Bar`
 }
 
 fn main() {
diff --git a/src/test/compile-fail/privacy-ns2.rs b/src/test/compile-fail/privacy-ns2.rs
index c75b12165c0..5ce0fb7e56a 100644
--- a/src/test/compile-fail/privacy-ns2.rs
+++ b/src/test/compile-fail/privacy-ns2.rs
@@ -15,6 +15,7 @@
 #![allow(dead_code)]
 #![allow(unused_imports)]
 
+
 // public type, private value
 pub mod foo1 {
     pub trait Bar {
@@ -49,13 +50,13 @@ pub mod foo2 {
 fn test_single2() {
     use foo2::Bar;  //~ ERROR `Bar` is private
 
-    let _x : ~Bar;
+    let _x : Box<Bar>;
 }
 
 fn test_list2() {
     use foo2::{Bar,Baz};  //~ ERROR `Bar` is private
 
-    let _x: ~Bar;
+    let _x: Box<Bar>;
 }
 
 // neither public
@@ -76,14 +77,14 @@ fn test_single3() {
     use foo3::Bar;  //~ ERROR `Bar` is private
 
     Bar();
-    let _x: ~Bar;
+    let _x: Box<Bar>;
 }
 
 fn test_list3() {
     use foo3::{Bar,Baz};  //~ ERROR `Bar` is private
 
     Bar();
-    let _x: ~Bar;
+    let _x: Box<Bar>;
 }
 
 fn main() {
diff --git a/src/test/compile-fail/regions-bound-lists-feature-gate.rs b/src/test/compile-fail/regions-bound-lists-feature-gate.rs
index 05050b72e5e..aa398bcd557 100644
--- a/src/test/compile-fail/regions-bound-lists-feature-gate.rs
+++ b/src/test/compile-fail/regions-bound-lists-feature-gate.rs
@@ -8,9 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 trait Foo { }
 
-fn foo<'a>(x: ~Foo:'a) { //~ ERROR only the 'static lifetime is accepted here
+fn foo<'a>(x: Box<Foo:'a>) { //~ ERROR only the 'static lifetime is accepted here
 }
 
 fn bar<'a, T:'a>() { //~ ERROR only the 'static lifetime is accepted here
diff --git a/src/test/compile-fail/regions-ref-in-fn-arg.rs b/src/test/compile-fail/regions-ref-in-fn-arg.rs
index 8c8404f7abc..47fca8bb8df 100644
--- a/src/test/compile-fail/regions-ref-in-fn-arg.rs
+++ b/src/test/compile-fail/regions-ref-in-fn-arg.rs
@@ -8,14 +8,15 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn arg_item(~ref x: ~int) -> &'static int {
+
+fn arg_item(box ref x: Box<int>) -> &'static int {
     x //~^ ERROR borrowed value does not live long enough
 }
 
-fn with<R>(f: |~int| -> R) -> R { f(~3) }
+fn with<R>(f: |Box<int>| -> R) -> R { f(box 3) }
 
 fn arg_closure() -> &'static int {
-    with(|~ref x| x) //~ ERROR borrowed value does not live long enough
+    with(|box ref x| x) //~ ERROR borrowed value does not live long enough
 }
 
 fn main() {}
diff --git a/src/test/compile-fail/regions-trait-1.rs b/src/test/compile-fail/regions-trait-1.rs
index 7aa545ab1b9..7771a71c79b 100644
--- a/src/test/compile-fail/regions-trait-1.rs
+++ b/src/test/compile-fail/regions-trait-1.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 struct ctxt { v: uint }
 
 trait get_ctxt {
@@ -27,12 +28,12 @@ impl<'a> get_ctxt for has_ctxt<'a> {
 
 }
 
-fn get_v(gc: ~get_ctxt) -> uint {
+fn get_v(gc: Box<get_ctxt>) -> uint {
     gc.get_ctxt().v
 }
 
 fn main() {
     let ctxt = ctxt { v: 22u };
     let hc = has_ctxt { c: &ctxt };
-    assert_eq!(get_v(~hc as ~get_ctxt), 22u);
+    assert_eq!(get_v(box hc as Box<get_ctxt>), 22u);
 }
diff --git a/src/test/compile-fail/removed-syntax-closure-lifetime.rs b/src/test/compile-fail/removed-syntax-closure-lifetime.rs
index e2ab70b1678..c5c8aa043f3 100644
--- a/src/test/compile-fail/removed-syntax-closure-lifetime.rs
+++ b/src/test/compile-fail/removed-syntax-closure-lifetime.rs
@@ -8,4 +8,4 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-type closure = ~lt/fn(); //~ ERROR expected `;` but found `/`
+type closure = Box<lt/fn()>; //~ ERROR expected `,` but found `/`
diff --git a/src/test/compile-fail/removed-syntax-uniq-mut-expr.rs b/src/test/compile-fail/removed-syntax-uniq-mut-expr.rs
index 0c2693a898b..5603cd21f3b 100644
--- a/src/test/compile-fail/removed-syntax-uniq-mut-expr.rs
+++ b/src/test/compile-fail/removed-syntax-uniq-mut-expr.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 fn f() {
-    let a_box = ~mut 42;
+    let a_box = box mut 42;
     //~^  ERROR found `mut` in ident position
     //~^^ ERROR expected `;` but found `42`
 }
diff --git a/src/test/compile-fail/removed-syntax-uniq-mut-ty.rs b/src/test/compile-fail/removed-syntax-uniq-mut-ty.rs
index 98ab7522966..128dbbd9cab 100644
--- a/src/test/compile-fail/removed-syntax-uniq-mut-ty.rs
+++ b/src/test/compile-fail/removed-syntax-uniq-mut-ty.rs
@@ -8,6 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-type mut_box = ~mut int;
+type mut_box = Box<mut int>;
     //~^  ERROR found `mut` in ident position
-    //~^^ ERROR expected `;` but found `int`
+    //~^^ ERROR expected `,` but found `int`
diff --git a/src/test/compile-fail/removed-syntax-uniq-self.rs b/src/test/compile-fail/removed-syntax-uniq-self.rs
deleted file mode 100644
index 8fb9c5e0e6f..00000000000
--- a/src/test/compile-fail/removed-syntax-uniq-self.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-struct S;
-
-impl S {
-    fn f(~mut self) {} //~ ERROR found `self` in ident position
-    //~^ ERROR expected `:` but found `)`
-}
diff --git a/src/test/compile-fail/selftype-traittype.rs b/src/test/compile-fail/selftype-traittype.rs
index 73df5c3967c..3bf547e3aff 100644
--- a/src/test/compile-fail/selftype-traittype.rs
+++ b/src/test/compile-fail/selftype-traittype.rs
@@ -8,11 +8,12 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 trait add {
     fn plus(&self, x: Self) -> Self;
 }
 
-fn do_add(x: ~add, y: ~add) -> ~add {
+fn do_add(x: Box<add>, y: Box<add>) -> Box<add> {
     x.plus(y) //~ ERROR cannot call a method whose type contains a self-type through an object
 }
 
diff --git a/src/test/compile-fail/static-mut-not-constant.rs b/src/test/compile-fail/static-mut-not-constant.rs
index 90dabb7e3a2..927006adc9e 100644
--- a/src/test/compile-fail/static-mut-not-constant.rs
+++ b/src/test/compile-fail/static-mut-not-constant.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-static mut a: ~int = ~3; //~ ERROR: mutable static items are not allowed to have owned pointers
+
+static mut a: Box<int> = box 3;
+//~^ ERROR mutable static items are not allowed to have owned pointers
 
 fn main() {}
diff --git a/src/test/compile-fail/struct-fields-missing.rs b/src/test/compile-fail/struct-fields-missing.rs
index 81d2ea3b959..0afc84ee1b3 100644
--- a/src/test/compile-fail/struct-fields-missing.rs
+++ b/src/test/compile-fail/struct-fields-missing.rs
@@ -8,9 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 struct BuildData {
     foo: int,
-    bar: ~int
+    bar: Box<int>,
 }
 
 fn main() {
diff --git a/src/test/compile-fail/trait-bounds-cant-coerce.rs b/src/test/compile-fail/trait-bounds-cant-coerce.rs
index 958a97412bc..12205ef062d 100644
--- a/src/test/compile-fail/trait-bounds-cant-coerce.rs
+++ b/src/test/compile-fail/trait-bounds-cant-coerce.rs
@@ -8,17 +8,18 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 trait Foo {
 }
 
-fn a(_x: ~Foo:Send) {
+fn a(_x: Box<Foo:Send>) {
 }
 
-fn c(x: ~Foo:Share+Send) {
+fn c(x: Box<Foo:Share+Send>) {
     a(x);
 }
 
-fn d(x: ~Foo:) {
+fn d(x: Box<Foo:>) {
     a(x); //~ ERROR found no bounds
 }
 
diff --git a/src/test/compile-fail/trait-bounds-not-on-struct.rs b/src/test/compile-fail/trait-bounds-not-on-struct.rs
index ebffd0303e0..be5375d2938 100644
--- a/src/test/compile-fail/trait-bounds-not-on-struct.rs
+++ b/src/test/compile-fail/trait-bounds-not-on-struct.rs
@@ -8,8 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 struct Foo;
 
-fn foo(_x: ~Foo:Send) { } //~ ERROR kind bounds can only be used on trait types
+fn foo(_x: Box<Foo:Send>) { } //~ ERROR kind bounds can only be used on trait types
 
 fn main() { }
diff --git a/src/test/compile-fail/trait-bounds-sugar.rs b/src/test/compile-fail/trait-bounds-sugar.rs
index 32c23a3efdd..9447030a7f4 100644
--- a/src/test/compile-fail/trait-bounds-sugar.rs
+++ b/src/test/compile-fail/trait-bounds-sugar.rs
@@ -10,15 +10,16 @@
 
 // Tests for "default" bounds inferred for traits with no bounds list.
 
+
 trait Foo {}
 
-fn a(_x: ~Foo:Send) {
+fn a(_x: Box<Foo:Send>) {
 }
 
 fn b(_x: &'static Foo) { // should be same as &'static Foo:'static
 }
 
-fn c(x: ~Foo:Share) {
+fn c(x: Box<Foo:Share>) {
     a(x); //~ ERROR expected bounds `Send`
 }
 
diff --git a/src/test/compile-fail/trait-coercion-generic-bad.rs b/src/test/compile-fail/trait-coercion-generic-bad.rs
index 297d36c3a0e..7c4b633fa9e 100644
--- a/src/test/compile-fail/trait-coercion-generic-bad.rs
+++ b/src/test/compile-fail/trait-coercion-generic-bad.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 struct Struct {
     person: &'static str
 }
@@ -23,7 +24,7 @@ impl Trait<&'static str> for Struct {
 }
 
 fn main() {
-    let s: ~Trait<int> = ~Struct { person: "Fred" };
+    let s: Box<Trait<int>> = box Struct { person: "Fred" };
     //~^ ERROR expected Trait<int>, but found Trait<&'static str>
     //~^^ ERROR expected Trait<int>, but found Trait<&'static str>
     s.f(1);
diff --git a/src/test/compile-fail/trait-coercion-generic-regions.rs b/src/test/compile-fail/trait-coercion-generic-regions.rs
index 6ffee2ef22b..04239de2a83 100644
--- a/src/test/compile-fail/trait-coercion-generic-regions.rs
+++ b/src/test/compile-fail/trait-coercion-generic-regions.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 struct Struct {
     person: &'static str
 }
@@ -25,6 +26,6 @@ impl Trait<&'static str> for Struct {
 fn main() {
     let person = "Fred".to_owned();
     let person: &str = person;  //~ ERROR `person[..]` does not live long enough
-    let s: ~Trait<&'static str> = ~Struct { person: person };
+    let s: Box<Trait<&'static str>> = box Struct { person: person };
 }
 
diff --git a/src/test/compile-fail/trait-test-2.rs b/src/test/compile-fail/trait-test-2.rs
index acac7ae9556..5e0340ce4f5 100644
--- a/src/test/compile-fail/trait-test-2.rs
+++ b/src/test/compile-fail/trait-test-2.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 trait bar { fn dup(&self) -> Self; fn blah<X>(&self); }
 impl bar for int { fn dup(&self) -> int { *self } fn blah<X>(&self) {} }
 impl bar for uint { fn dup(&self) -> uint { *self } fn blah<X>(&self) {} }
@@ -15,5 +16,5 @@ impl bar for uint { fn dup(&self) -> uint { *self } fn blah<X>(&self) {} }
 fn main() {
     10i.dup::<int>(); //~ ERROR does not take type parameters
     10i.blah::<int, int>(); //~ ERROR incorrect number of type parameters
-    (~10 as ~bar).dup(); //~ ERROR contains a self-type
+    (box 10 as Box<bar>).dup(); //~ ERROR contains a self-type
 }
diff --git a/src/test/compile-fail/unique-object-noncopyable.rs b/src/test/compile-fail/unique-object-noncopyable.rs
index 843b61c9dbe..e237e2c8b75 100644
--- a/src/test/compile-fail/unique-object-noncopyable.rs
+++ b/src/test/compile-fail/unique-object-noncopyable.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 trait Foo {
     fn f(&self);
 }
@@ -27,7 +28,7 @@ impl Foo for Bar {
 }
 
 fn main() {
-    let x = ~Bar { x: 10 };
-    let y: ~Foo = x as ~Foo;
+    let x = box Bar { x: 10 };
+    let y: Box<Foo> = x as Box<Foo>;
     let _z = y.clone(); //~ ERROR does not implement any method in scope
 }
diff --git a/src/test/compile-fail/unique-pinned-nocopy.rs b/src/test/compile-fail/unique-pinned-nocopy.rs
index da9e24b7314..04d8bc96a47 100644
--- a/src/test/compile-fail/unique-pinned-nocopy.rs
+++ b/src/test/compile-fail/unique-pinned-nocopy.rs
@@ -17,7 +17,7 @@ impl Drop for r {
 }
 
 fn main() {
-    let i = ~r { b: true };
+    let i = box r { b: true };
     let _j = i.clone(); //~ ERROR failed to find an implementation
     println!("{:?}", i);
 }
diff --git a/src/test/compile-fail/unique-unique-kind.rs b/src/test/compile-fail/unique-unique-kind.rs
index 8e951cc9b55..6a62256b881 100644
--- a/src/test/compile-fail/unique-unique-kind.rs
+++ b/src/test/compile-fail/unique-unique-kind.rs
@@ -14,6 +14,6 @@ fn f<T:Send>(_i: T) {
 }
 
 fn main() {
-    let i = ~@100;
+    let i = box @100;
     f(i); //~ ERROR does not fulfill `Send`
 }
diff --git a/src/test/compile-fail/unique-vec-res.rs b/src/test/compile-fail/unique-vec-res.rs
index b83277b38a6..adeecf2babf 100644
--- a/src/test/compile-fail/unique-vec-res.rs
+++ b/src/test/compile-fail/unique-vec-res.rs
@@ -31,8 +31,8 @@ fn f<T>(_i: Vec<T> , _j: Vec<T> ) {
 fn main() {
     let i1 = @Cell::new(0);
     let i2 = @Cell::new(1);
-    let r1 = vec!(~r { i: i1 });
-    let r2 = vec!(~r { i: i2 });
+    let r1 = vec!(box r { i: i1 });
+    let r2 = vec!(box r { i: i2 });
     f(r1.clone(), r2.clone());
     //~^ ERROR failed to find an implementation of
     println!("{:?}", (r2, i1.get()));
diff --git a/src/test/compile-fail/unreachable-arm.rs b/src/test/compile-fail/unreachable-arm.rs
index b983eabb743..e356f87af69 100644
--- a/src/test/compile-fail/unreachable-arm.rs
+++ b/src/test/compile-fail/unreachable-arm.rs
@@ -10,6 +10,7 @@
 
 // error-pattern:unreachable pattern
 
-enum foo { a(~foo, int), b(uint), }
 
-fn main() { match b(1u) { b(_) | a(~_, 1) => { } a(_, 1) => { } } }
+enum foo { a(Box<foo>, int), b(uint), }
+
+fn main() { match b(1u) { b(_) | a(box _, 1) => { } a(_, 1) => { } } }
diff --git a/src/test/compile-fail/unsized3.rs b/src/test/compile-fail/unsized3.rs
index 0ff5b1c9b5a..c321871c40f 100644
--- a/src/test/compile-fail/unsized3.rs
+++ b/src/test/compile-fail/unsized3.rs
@@ -10,6 +10,7 @@
 
 // Test sized-ness checking in substitution.
 
+
 // Unbounded.
 fn f1<type X>(x: &X) {
     f2::<X>(x); //~ ERROR instantiating a type parameter with an incompatible type `X`, which does n
@@ -49,7 +50,7 @@ fn f8<type X>(x1: &S<X>, x2: &S<X>) {
 }
 
 // Test some tuples.
-fn f9<type X>(x1: ~S<X>, x2: ~E<X>) {
+fn f9<type X>(x1: Box<S<X>>, x2: Box<E<X>>) {
     f5(&(*x1, 34)); //~ERROR instantiating a type parameter with an incompatible type `(S<X>,int)`,
     f5(&(32, *x2)); //~ERROR instantiating a type parameter with an incompatible type `(int,E<X>)`,
 }
diff --git a/src/test/compile-fail/unsized6.rs b/src/test/compile-fail/unsized6.rs
index a763373e364..9916fdba20f 100644
--- a/src/test/compile-fail/unsized6.rs
+++ b/src/test/compile-fail/unsized6.rs
@@ -10,6 +10,7 @@
 
 // Test `type` local variables.
 
+
 trait T for type {}
 
 fn f1<type X>(x: &X) {
@@ -25,12 +26,12 @@ fn f2<type X: T>(x: &X) {
     let y: (int, (X, int)); //~ERROR variable `y` has dynamically sized type `(int,(X,int))`
 }
 
-fn f3<type X>(x1: ~X, x2: ~X, x3: ~X) {
+fn f3<type X>(x1: Box<X>, x2: Box<X>, x3: Box<X>) {
     let y: X = *x1; //~ERROR variable `y` has dynamically sized type `X`
     let y = *x2; //~ERROR variable `y` has dynamically sized type `X`
     let (y, z) = (*x3, 4); //~ERROR variable `y` has dynamically sized type `X`
 }
-fn f4<type X: T>(x1: ~X, x2: ~X, x3: ~X) {
+fn f4<type X: T>(x1: Box<X>, x2: Box<X>, x3: Box<X>) {
     let y: X = *x1;         //~ERROR variable `y` has dynamically sized type `X`
     let y = *x2;            //~ERROR variable `y` has dynamically sized type `X`
     let (y, z) = (*x3, 4); //~ERROR variable `y` has dynamically sized type `X`
diff --git a/src/test/compile-fail/use-after-move-implicity-coerced-object.rs b/src/test/compile-fail/use-after-move-implicity-coerced-object.rs
index 4d57470a721..e95ab71e5aa 100644
--- a/src/test/compile-fail/use-after-move-implicity-coerced-object.rs
+++ b/src/test/compile-fail/use-after-move-implicity-coerced-object.rs
@@ -23,17 +23,17 @@ impl fmt::Show for Number {
 }
 
 struct List {
-    list: Vec<~ToStr> }
+    list: Vec<Box<ToStr>> }
 
 impl List {
-    fn push(&mut self, n: ~ToStr) {
+    fn push(&mut self, n: Box<ToStr>) {
         self.list.push(n);
     }
 }
 
 fn main() {
-    let n = ~Number { n: 42 };
-    let mut l = ~List { list: Vec::new() };
+    let n = box Number { n: 42 };
+    let mut l = box List { list: Vec::new() };
     l.push(n);
     let x = n.to_str();
     //~^ ERROR: use of moved value: `n`
diff --git a/src/test/compile-fail/use-after-move-self.rs b/src/test/compile-fail/use-after-move-self.rs
index 56e5fdce3cf..8d1ab1bcd94 100644
--- a/src/test/compile-fail/use-after-move-self.rs
+++ b/src/test/compile-fail/use-after-move-self.rs
@@ -8,8 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 struct S {
-    x: ~int
+    x: Box<int>,
 }
 
 impl S {
@@ -22,6 +23,6 @@ impl S {
 }
 
 fn main() {
-    let x = S { x: ~1 };
+    let x = S { x: box 1 };
     println!("{}", x.foo());
 }
diff --git a/src/test/debug-info/borrowed-struct.rs b/src/test/debug-info/borrowed-struct.rs
index c5f4bf0ac62..e271a221611 100644
--- a/src/test/debug-info/borrowed-struct.rs
+++ b/src/test/debug-info/borrowed-struct.rs
@@ -65,7 +65,7 @@ fn main() {
     let managed_val_interior_ref_1: &int = &managed_val.x;
     let managed_val_interior_ref_2: &f64 = &managed_val.y;
 
-    let unique_val = ~SomeStruct { x: 13, y: 26.5 };
+    let unique_val = box SomeStruct { x: 13, y: 26.5 };
     let unique_val_ref: &SomeStruct = unique_val;
     let unique_val_interior_ref_1: &int = &unique_val.x;
     let unique_val_interior_ref_2: &f64 = &unique_val.y;
diff --git a/src/test/debug-info/borrowed-tuple.rs b/src/test/debug-info/borrowed-tuple.rs
index 5cc69c94d59..b619f8e8ba1 100644
--- a/src/test/debug-info/borrowed-tuple.rs
+++ b/src/test/debug-info/borrowed-tuple.rs
@@ -31,6 +31,7 @@
 
 #![allow(unused_variable)]
 
+
 fn main() {
     let stack_val: (i16, f32) = (-14, -19f32);
     let stack_val_ref: &(i16, f32) = &stack_val;
@@ -39,7 +40,7 @@ fn main() {
     let managed_val: @(i16, f32) = @(-16, -21f32);
     let managed_val_ref: &(i16, f32) = managed_val;
 
-    let unique_val: ~(i16, f32) = ~(-17, -22f32);
+    let unique_val: Box<(i16, f32)> = box() (-17, -22f32);
     let unique_val_ref: &(i16, f32) = unique_val;
 
     zzz();
diff --git a/src/test/debug-info/borrowed-unique-basic.rs b/src/test/debug-info/borrowed-unique-basic.rs
index 98cf0905f2a..eaa2679e698 100644
--- a/src/test/debug-info/borrowed-unique-basic.rs
+++ b/src/test/debug-info/borrowed-unique-basic.rs
@@ -63,46 +63,46 @@
 
 
 fn main() {
-    let bool_box: ~bool = ~true;
+    let bool_box: Box<bool> = box true;
     let bool_ref: &bool = bool_box;
 
-    let int_box: ~int = ~-1;
+    let int_box: Box<int> = box -1;
     let int_ref: &int = int_box;
 
-    let char_box: ~char = ~'a';
+    let char_box: Box<char> = box 'a';
     let char_ref: &char = char_box;
 
-    let i8_box: ~i8 = ~68;
+    let i8_box: Box<i8> = box 68;
     let i8_ref: &i8 = i8_box;
 
-    let i16_box: ~i16 = ~-16;
+    let i16_box: Box<i16> = box -16;
     let i16_ref: &i16 = i16_box;
 
-    let i32_box: ~i32 = ~-32;
+    let i32_box: Box<i32> = box -32;
     let i32_ref: &i32 = i32_box;
 
-    let i64_box: ~i64 = ~-64;
+    let i64_box: Box<i64> = box -64;
     let i64_ref: &i64 = i64_box;
 
-    let uint_box: ~uint = ~1;
+    let uint_box: Box<uint> = box 1;
     let uint_ref: &uint = uint_box;
 
-    let u8_box: ~u8 = ~100;
+    let u8_box: Box<u8> = box 100;
     let u8_ref: &u8 = u8_box;
 
-    let u16_box: ~u16 = ~16;
+    let u16_box: Box<u16> = box 16;
     let u16_ref: &u16 = u16_box;
 
-    let u32_box: ~u32 = ~32;
+    let u32_box: Box<u32> = box 32;
     let u32_ref: &u32 = u32_box;
 
-    let u64_box: ~u64 = ~64;
+    let u64_box: Box<u64> = box 64;
     let u64_ref: &u64 = u64_box;
 
-    let f32_box: ~f32 = ~2.5;
+    let f32_box: Box<f32> = box 2.5;
     let f32_ref: &f32 = f32_box;
 
-    let f64_box: ~f64 = ~3.5;
+    let f64_box: Box<f64> = box 3.5;
     let f64_ref: &f64 = f64_box;
     zzz();
 }
diff --git a/src/test/debug-info/box.rs b/src/test/debug-info/box.rs
index 208dd52f9ac..a849a058332 100644
--- a/src/test/debug-info/box.rs
+++ b/src/test/debug-info/box.rs
@@ -28,8 +28,8 @@
 #![allow(unused_variable)]
 
 fn main() {
-    let a = ~1;
-    let b = ~(2, 3.5);
+    let a = box 1;
+    let b = box() (2, 3.5);
     let c = @4;
     let d = @false;
     _zzz();
diff --git a/src/test/debug-info/boxed-struct.rs b/src/test/debug-info/boxed-struct.rs
index 84b35134ad5..a286fca22c1 100644
--- a/src/test/debug-info/boxed-struct.rs
+++ b/src/test/debug-info/boxed-struct.rs
@@ -30,6 +30,7 @@
 #![feature(managed_boxes)]
 #![allow(unused_variable)]
 
+
 struct StructWithSomePadding {
     x: i16,
     y: i32,
@@ -50,10 +51,10 @@ impl Drop for StructWithDestructor {
 
 fn main() {
 
-    let unique = ~StructWithSomePadding { x: 99, y: 999, z: 9999, w: 99999 };
+    let unique = box StructWithSomePadding { x: 99, y: 999, z: 9999, w: 99999 };
     let managed = @StructWithSomePadding { x: 88, y: 888, z: 8888, w: 88888 };
 
-    let unique_dtor = ~StructWithDestructor { x: 77, y: 777, z: 7777, w: 77777 };
+    let unique_dtor = box StructWithDestructor { x: 77, y: 777, z: 7777, w: 77777 };
     let managed_dtor = @StructWithDestructor { x: 33, y: 333, z: 3333, w: 33333 };
 
     zzz();
diff --git a/src/test/debug-info/closure-in-generic-function.rs b/src/test/debug-info/closure-in-generic-function.rs
index 1184ce8643b..f3692e7bf96 100644
--- a/src/test/debug-info/closure-in-generic-function.rs
+++ b/src/test/debug-info/closure-in-generic-function.rs
@@ -40,7 +40,7 @@ fn some_generic_fun<T1, T2>(a: T1, b: T2) -> (T2, T1) {
 
 fn main() {
     some_generic_fun(0.5, 10);
-    some_generic_fun(&29, ~110);
+    some_generic_fun(&29, box 110);
 }
 
 fn zzz() {()}
diff --git a/src/test/debug-info/destructured-fn-argument.rs b/src/test/debug-info/destructured-fn-argument.rs
index 246857d345c..2f7fc961cdd 100644
--- a/src/test/debug-info/destructured-fn-argument.rs
+++ b/src/test/debug-info/destructured-fn-argument.rs
@@ -183,6 +183,7 @@
 
 #![allow(unused_variable)]
 
+
 struct Struct {
     a: i64,
     b: i32
@@ -249,7 +250,7 @@ fn contained_borrowed_pointer((&cc, _): (&int, int)) {
     zzz();
 }
 
-fn unique_pointer(~dd: ~(int, int, int)) {
+fn unique_pointer(box dd: Box<(int, int, int)>) {
     zzz();
 }
 
@@ -299,7 +300,7 @@ fn main() {
     managed_box(&(34, 35));
     borrowed_pointer(&(36, 37));
     contained_borrowed_pointer((&38, 39));
-    unique_pointer(~(40, 41, 42));
+    unique_pointer(box() (40, 41, 42));
     ref_binding((43, 44, 45));
     ref_binding_in_tuple((46, (47, 48)));
     ref_binding_in_struct(Struct { a: 49, b: 50 });
diff --git a/src/test/debug-info/destructured-local.rs b/src/test/debug-info/destructured-local.rs
index 5aabf1fe82f..3dab6ace9a8 100644
--- a/src/test/debug-info/destructured-local.rs
+++ b/src/test/debug-info/destructured-local.rs
@@ -181,7 +181,7 @@ fn main() {
     let (&cc, _) = (&38, 39);
 
     // unique pointer
-    let ~dd = ~(40, 41, 42);
+    let box dd = box() (40, 41, 42);
 
     // ref binding
     let ref ee = (43, 44, 45);
diff --git a/src/test/debug-info/generic-method-on-generic-struct.rs b/src/test/debug-info/generic-method-on-generic-struct.rs
index 38d260678b7..7afa8952998 100644
--- a/src/test/debug-info/generic-method-on-generic-struct.rs
+++ b/src/test/debug-info/generic-method-on-generic-struct.rs
@@ -91,7 +91,7 @@ fn main() {
     let _ = stack.self_by_ref(-1, -2_i8);
     let _ = stack.self_by_val(-3, -4_i16);
 
-    let owned = ~Struct { x: 1234.5 };
+    let owned = box Struct { x: 1234.5 };
     let _ = owned.self_by_ref(-5, -6_i32);
     let _ = owned.self_by_val(-7, -8_i64);
     let _ = owned.self_owned(-9, -10.5_f32);
diff --git a/src/test/debug-info/managed-pointer-within-unique.rs b/src/test/debug-info/managed-pointer-within-unique.rs
index 79fb353ac4d..2207b3ef798 100644
--- a/src/test/debug-info/managed-pointer-within-unique.rs
+++ b/src/test/debug-info/managed-pointer-within-unique.rs
@@ -35,9 +35,9 @@ struct ContainsManaged {
 }
 
 fn main() {
-    let ordinary_unique = ~(-1, -2);
+    let ordinary_unique = box() (-1, -2);
 
-    let managed_within_unique = ~ContainsManaged { x: -3, y: @-4 };
+    let managed_within_unique = box ContainsManaged { x: -3, y: @-4 };
 
     zzz();
 }
diff --git a/src/test/debug-info/method-on-enum.rs b/src/test/debug-info/method-on-enum.rs
index 3ef78c49a54..9c8718a4295 100644
--- a/src/test/debug-info/method-on-enum.rs
+++ b/src/test/debug-info/method-on-enum.rs
@@ -94,7 +94,7 @@ fn main() {
     let _ = stack.self_by_ref(-1, -2);
     let _ = stack.self_by_val(-3, -4);
 
-    let owned = ~Variant1{ x: 1799, y: 1799 };
+    let owned = box Variant1{ x: 1799, y: 1799 };
     let _ = owned.self_by_ref(-5, -6);
     let _ = owned.self_by_val(-7, -8);
     let _ = owned.self_owned(-9, -10);
diff --git a/src/test/debug-info/method-on-generic-struct.rs b/src/test/debug-info/method-on-generic-struct.rs
index 1c82fec2a8b..f2cdadd8aad 100644
--- a/src/test/debug-info/method-on-generic-struct.rs
+++ b/src/test/debug-info/method-on-generic-struct.rs
@@ -91,7 +91,7 @@ fn main() {
     let _ = stack.self_by_ref(-1, -2);
     let _ = stack.self_by_val(-3, -4);
 
-    let owned = ~Struct { x: 1234.5 };
+    let owned = box Struct { x: 1234.5 };
     let _ = owned.self_by_ref(-5, -6);
     let _ = owned.self_by_val(-7, -8);
     let _ = owned.self_owned(-9, -10);
diff --git a/src/test/debug-info/method-on-struct.rs b/src/test/debug-info/method-on-struct.rs
index 1bfec62dedc..dcd285b0a14 100644
--- a/src/test/debug-info/method-on-struct.rs
+++ b/src/test/debug-info/method-on-struct.rs
@@ -91,7 +91,7 @@ fn main() {
     let _ = stack.self_by_ref(-1, -2);
     let _ = stack.self_by_val(-3, -4);
 
-    let owned = ~Struct { x: 200 };
+    let owned = box Struct { x: 200 };
     let _ = owned.self_by_ref(-5, -6);
     let _ = owned.self_by_val(-7, -8);
     let _ = owned.self_owned(-9, -10);
diff --git a/src/test/debug-info/method-on-trait.rs b/src/test/debug-info/method-on-trait.rs
index 473ed973bb5..6e1f8e6c72d 100644
--- a/src/test/debug-info/method-on-trait.rs
+++ b/src/test/debug-info/method-on-trait.rs
@@ -97,7 +97,7 @@ fn main() {
     let _ = stack.self_by_ref(-1, -2);
     let _ = stack.self_by_val(-3, -4);
 
-    let owned = ~Struct { x: 200 };
+    let owned = box Struct { x: 200 };
     let _ = owned.self_by_ref(-5, -6);
     let _ = owned.self_by_val(-7, -8);
     let _ = owned.self_owned(-9, -10);
diff --git a/src/test/debug-info/method-on-tuple-struct.rs b/src/test/debug-info/method-on-tuple-struct.rs
index d0b97a079cc..184bee99d87 100644
--- a/src/test/debug-info/method-on-tuple-struct.rs
+++ b/src/test/debug-info/method-on-tuple-struct.rs
@@ -89,7 +89,7 @@ fn main() {
     let _ = stack.self_by_ref(-1, -2);
     let _ = stack.self_by_val(-3, -4);
 
-    let owned = ~TupleStruct(200, -200.5);
+    let owned = box TupleStruct(200, -200.5);
     let _ = owned.self_by_ref(-5, -6);
     let _ = owned.self_by_val(-7, -8);
     let _ = owned.self_owned(-9, -10);
diff --git a/src/test/debug-info/recursive-struct.rs b/src/test/debug-info/recursive-struct.rs
index ca178468941..a46a1c248ff 100644
--- a/src/test/debug-info/recursive-struct.rs
+++ b/src/test/debug-info/recursive-struct.rs
@@ -105,13 +105,14 @@
 #![allow(unused_variable)]
 #![feature(struct_variant)]
 
+
 enum Opt<T> {
     Empty,
     Val { val: T }
 }
 
 struct UniqueNode<T> {
-    next: Opt<~UniqueNode<T>>,
+    next: Opt<Box<UniqueNode<T>>>,
     value: T
 }
 
@@ -121,27 +122,27 @@ struct ManagedNode<T> {
 }
 
 struct LongCycle1<T> {
-    next: ~LongCycle2<T>,
+    next: Box<LongCycle2<T>>,
     value: T,
 }
 
 struct LongCycle2<T> {
-    next: ~LongCycle3<T>,
+    next: Box<LongCycle3<T>>,
     value: T,
 }
 
 struct LongCycle3<T> {
-    next: ~LongCycle4<T>,
+    next: Box<LongCycle4<T>>,
     value: T,
 }
 
 struct LongCycle4<T> {
-    next: Option<~LongCycle1<T>>,
+    next: Option<Box<LongCycle1<T>>>,
     value: T,
 }
 
 struct LongCycleWithAnonymousTypes {
-    next: Opt<~~~~~LongCycleWithAnonymousTypes>,
+    next: Opt<Box<Box<Box<Box<Box<LongCycleWithAnonymousTypes>>>>>>,
     value: uint,
 }
 
@@ -163,7 +164,7 @@ struct LongCycleWithAnonymousTypes {
 fn main() {
     let stack_unique: UniqueNode<u16> = UniqueNode {
         next: Val {
-            val: ~UniqueNode {
+            val: box UniqueNode {
                 next: Empty,
                 value: 1_u16,
             }
@@ -171,9 +172,9 @@ fn main() {
         value: 0_u16,
     };
 
-    let unique_unique: ~UniqueNode<u32> = ~UniqueNode {
+    let unique_unique: Box<UniqueNode<u32>> = box UniqueNode {
         next: Val {
-            val: ~UniqueNode {
+            val: box UniqueNode {
                 next: Empty,
                 value: 3,
             }
@@ -183,7 +184,7 @@ fn main() {
 
     let box_unique: @UniqueNode<u64> = @UniqueNode {
         next: Val {
-            val: ~UniqueNode {
+            val: box UniqueNode {
                 next: Empty,
                 value: 5,
             }
@@ -193,7 +194,7 @@ fn main() {
 
     let vec_unique: [UniqueNode<f32>, ..1] = [UniqueNode {
         next: Val {
-            val: ~UniqueNode {
+            val: box UniqueNode {
                 next: Empty,
                 value: 7.5,
             }
@@ -203,7 +204,7 @@ fn main() {
 
     let borrowed_unique: &UniqueNode<f64> = &UniqueNode {
         next: Val {
-            val: ~UniqueNode {
+            val: box UniqueNode {
                 next: Empty,
                 value: 9.5,
             }
@@ -221,7 +222,7 @@ fn main() {
         value: 10,
     };
 
-    let unique_managed: ~ManagedNode<u32> = ~ManagedNode {
+    let unique_managed: Box<ManagedNode<u32>> = box ManagedNode {
         next: Val {
             val: @ManagedNode {
                 next: Empty,
@@ -263,9 +264,9 @@ fn main() {
 
     // LONG CYCLE
     let long_cycle1: LongCycle1<u16> = LongCycle1 {
-        next: ~LongCycle2 {
-            next: ~LongCycle3 {
-                next: ~LongCycle4 {
+        next: box LongCycle2 {
+            next: box LongCycle3 {
+                next: box LongCycle4 {
                     next: None,
                     value: 23,
                 },
@@ -277,8 +278,8 @@ fn main() {
     };
 
     let long_cycle2: LongCycle2<u32> = LongCycle2 {
-        next: ~LongCycle3 {
-            next: ~LongCycle4 {
+        next: box LongCycle3 {
+            next: box LongCycle4 {
                 next: None,
                 value: 26,
             },
@@ -288,7 +289,7 @@ fn main() {
     };
 
     let long_cycle3: LongCycle3<u64> = LongCycle3 {
-        next: ~LongCycle4 {
+        next: box LongCycle4 {
             next: None,
             value: 28,
         },
@@ -301,10 +302,10 @@ fn main() {
     };
 
     // It's important that LongCycleWithAnonymousTypes is encountered only at the end of the
-    // `~` chain.
-    let long_cycle_w_anonymous_types = ~~~~~LongCycleWithAnonymousTypes {
+    // `box` chain.
+    let long_cycle_w_anonymous_types = box box box box box LongCycleWithAnonymousTypes {
         next: Val {
-            val: ~~~~~LongCycleWithAnonymousTypes {
+            val: box box box box box LongCycleWithAnonymousTypes {
                 next: Empty,
                 value: 31,
             }
diff --git a/src/test/debug-info/self-in-default-method.rs b/src/test/debug-info/self-in-default-method.rs
index c8ab9d1f0bc..194cfc77bf3 100644
--- a/src/test/debug-info/self-in-default-method.rs
+++ b/src/test/debug-info/self-in-default-method.rs
@@ -92,7 +92,7 @@ fn main() {
     let _ = stack.self_by_ref(-1, -2);
     let _ = stack.self_by_val(-3, -4);
 
-    let owned = ~Struct { x: 200 };
+    let owned = box Struct { x: 200 };
     let _ = owned.self_by_ref(-5, -6);
     let _ = owned.self_by_val(-7, -8);
     let _ = owned.self_owned(-9, -10);
diff --git a/src/test/debug-info/self-in-generic-default-method.rs b/src/test/debug-info/self-in-generic-default-method.rs
index 51fb8860761..9e7504be15b 100644
--- a/src/test/debug-info/self-in-generic-default-method.rs
+++ b/src/test/debug-info/self-in-generic-default-method.rs
@@ -93,7 +93,7 @@ fn main() {
     let _ = stack.self_by_ref(-1, -2_i8);
     let _ = stack.self_by_val(-3, -4_i16);
 
-    let owned = ~Struct { x: 879 };
+    let owned = box Struct { x: 879 };
     let _ = owned.self_by_ref(-5, -6_i32);
     let _ = owned.self_by_val(-7, -8_i64);
     let _ = owned.self_owned(-9, -10.5_f32);
diff --git a/src/test/debug-info/trait-pointers.rs b/src/test/debug-info/trait-pointers.rs
index 8d114a3f8dd..fcb0f6082a3 100644
--- a/src/test/debug-info/trait-pointers.rs
+++ b/src/test/debug-info/trait-pointers.rs
@@ -15,6 +15,7 @@
 
 #![allow(unused_variable)]
 
+
 trait Trait {
     fn method(&self) -> int { 0 }
 }
@@ -30,5 +31,5 @@ impl Trait for Struct {}
 fn main() {
     let stack_struct = Struct { a:0, b: 1.0 };
     let reference: &Trait = &stack_struct as &Trait;
-    let unique: ~Trait = ~Struct { a:2, b: 3.0 } as ~Trait;
+    let unique: Box<Trait> = box Struct { a:2, b: 3.0 } as Box<Trait>;
 }
diff --git a/src/test/debug-info/unique-enum.rs b/src/test/debug-info/unique-enum.rs
index 1c2cc883285..45f0213bf8c 100644
--- a/src/test/debug-info/unique-enum.rs
+++ b/src/test/debug-info/unique-enum.rs
@@ -50,15 +50,15 @@ fn main() {
     // 0b01111100011111000111110001111100 = 2088533116
     // 0b0111110001111100 = 31868
     // 0b01111100 = 124
-    let the_a = ~TheA { x: 0, y: 8970181431921507452 };
+    let the_a = box TheA { x: 0, y: 8970181431921507452 };
 
     // 0b0001000100010001000100010001000100010001000100010001000100010001 = 1229782938247303441
     // 0b00010001000100010001000100010001 = 286331153
     // 0b0001000100010001 = 4369
     // 0b00010001 = 17
-    let the_b = ~TheB (0, 286331153, 286331153);
+    let the_b = box TheB (0, 286331153, 286331153);
 
-    let univariant = ~TheOnlyCase(123234);
+    let univariant = box TheOnlyCase(123234);
 
     zzz();
 }
diff --git a/src/test/debug-info/var-captured-in-nested-closure.rs b/src/test/debug-info/var-captured-in-nested-closure.rs
index 8dd22e60617..7677c9e9235 100644
--- a/src/test/debug-info/var-captured-in-nested-closure.rs
+++ b/src/test/debug-info/var-captured-in-nested-closure.rs
@@ -68,7 +68,7 @@ fn main() {
     };
 
     let struct_ref = &a_struct;
-    let owned = ~6;
+    let owned = box 6;
     let managed = @7;
 
     let closure = || {
diff --git a/src/test/debug-info/var-captured-in-sendable-closure.rs b/src/test/debug-info/var-captured-in-sendable-closure.rs
index 83b26e08975..4316e503a51 100644
--- a/src/test/debug-info/var-captured-in-sendable-closure.rs
+++ b/src/test/debug-info/var-captured-in-sendable-closure.rs
@@ -39,7 +39,7 @@ fn main() {
         c: 4
     };
 
-    let owned = ~5;
+    let owned = box 5;
 
     let closure: proc() = proc() {
         zzz();
diff --git a/src/test/debug-info/var-captured-in-stack-closure.rs b/src/test/debug-info/var-captured-in-stack-closure.rs
index 4daaf8f7a0e..57dcabe90b6 100644
--- a/src/test/debug-info/var-captured-in-stack-closure.rs
+++ b/src/test/debug-info/var-captured-in-stack-closure.rs
@@ -48,7 +48,7 @@ fn main() {
     };
 
     let struct_ref = &a_struct;
-    let owned = ~6;
+    let owned = box 6;
     let managed = @7;
 
     let closure = || {
diff --git a/src/test/pretty/path-type-bounds.rs b/src/test/pretty/path-type-bounds.rs
index 7b09c589320..0fdbad67f16 100644
--- a/src/test/pretty/path-type-bounds.rs
+++ b/src/test/pretty/path-type-bounds.rs
@@ -10,14 +10,15 @@
 
 // pp-exact
 
+
 trait Tr { }
 impl Tr for int { }
 
-fn foo(x: ~Tr: Share) -> ~Tr: Share { x }
+fn foo(x: Box<Tr: Share>) -> Box<Tr: Share> { x }
 
 fn main() {
-    let x: ~Tr: Share;
+    let x: Box<Tr: Share>;
 
-    ~1 as ~Tr: Share;
+    box() 1 as Box<Tr: Share>;
 }
 
diff --git a/src/test/run-fail/fail-macro-any-wrapped.rs b/src/test/run-fail/fail-macro-any-wrapped.rs
index 5a3dda88f70..e1eea1d89b9 100644
--- a/src/test/run-fail/fail-macro-any-wrapped.rs
+++ b/src/test/run-fail/fail-macro-any-wrapped.rs
@@ -8,8 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// error-pattern:failed at '~Any'
+// error-pattern:failed at 'Box<Any>'
 
 fn main() {
-    fail!(~612_i64);
+    fail!(box 612_i64);
 }
diff --git a/src/test/run-fail/fail-macro-any.rs b/src/test/run-fail/fail-macro-any.rs
index d812e19e1c8..09b50743308 100644
--- a/src/test/run-fail/fail-macro-any.rs
+++ b/src/test/run-fail/fail-macro-any.rs
@@ -8,8 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// error-pattern:failed at '~Any'
+// error-pattern:failed at 'Box<Any>'
+
 
 fn main() {
-    fail!(~413 as ~::std::any::Any:Send);
+    fail!(box 413 as Box<::std::any::Any:Send>);
 }
diff --git a/src/test/run-fail/issue-2272.rs b/src/test/run-fail/issue-2272.rs
index c27ddef8711..9ac5790f2b7 100644
--- a/src/test/run-fail/issue-2272.rs
+++ b/src/test/run-fail/issue-2272.rs
@@ -13,7 +13,8 @@
 // error-pattern:explicit failure
 // Issue #2272 - unwind this without leaking the unique pointer
 
-struct X { y: Y, a: ~int }
+
+struct X { y: Y, a: Box<int> }
 
 struct Y { z: @int }
 
@@ -22,7 +23,7 @@ fn main() {
         y: Y {
             z: @0
         },
-        a: ~0
+        a: box 0
     };
     fail!();
 }
diff --git a/src/test/run-fail/unique-fail.rs b/src/test/run-fail/unique-fail.rs
index 86fde5b7f97..f1804c10691 100644
--- a/src/test/run-fail/unique-fail.rs
+++ b/src/test/run-fail/unique-fail.rs
@@ -9,4 +9,4 @@
 // except according to those terms.
 
 // error-pattern: fail
-fn main() { ~fail!(); }
+fn main() { box fail!(); }
diff --git a/src/test/run-fail/unwind-box-fn-unique.rs b/src/test/run-fail/unwind-box-fn-unique.rs
index 3fabbdff9b3..50ecedd68fe 100644
--- a/src/test/run-fail/unwind-box-fn-unique.rs
+++ b/src/test/run-fail/unwind-box-fn-unique.rs
@@ -17,7 +17,7 @@ fn failfn() {
 }
 
 fn main() {
-    let y = ~0;
+    let y = box 0;
     let x: @proc():Send = @(proc() {
         println!("{:?}", y.clone());
     });
diff --git a/src/test/run-fail/unwind-box-res.rs b/src/test/run-fail/unwind-box-res.rs
index 2e4ebf5ea34..ecaae7f5cc7 100644
--- a/src/test/run-fail/unwind-box-res.rs
+++ b/src/test/run-fail/unwind-box-res.rs
@@ -25,7 +25,7 @@ struct r {
 impl Drop for r {
     fn drop(&mut self) {
         unsafe {
-            let _v2: ~int = cast::transmute(self.v);
+            let _v2: Box<int> = cast::transmute(self.v);
         }
     }
 }
@@ -38,7 +38,7 @@ fn r(v: *int) -> r {
 
 fn main() {
     unsafe {
-        let i1 = ~0;
+        let i1 = box 0;
         let i1p = cast::transmute_copy(&i1);
         cast::forget(i1);
         let x = @r(i1p);
diff --git a/src/test/run-fail/unwind-box-unique-unique.rs b/src/test/run-fail/unwind-box-unique-unique.rs
index dcfaccf5ab7..82da2bc6ca3 100644
--- a/src/test/run-fail/unwind-box-unique-unique.rs
+++ b/src/test/run-fail/unwind-box-unique-unique.rs
@@ -12,12 +12,13 @@
 
 #![feature(managed_boxes)]
 
+
 fn failfn() {
     fail!();
 }
 
 fn main() {
-    let x = @~~0;
+    let x = @box box 0;
     failfn();
     println!("{:?}", x);
 }
diff --git a/src/test/run-fail/unwind-box-unique.rs b/src/test/run-fail/unwind-box-unique.rs
index bfe72835f45..99adaaad314 100644
--- a/src/test/run-fail/unwind-box-unique.rs
+++ b/src/test/run-fail/unwind-box-unique.rs
@@ -17,7 +17,7 @@ fn failfn() {
 }
 
 fn main() {
-    let x = @~0;
+    let x = @box 0;
     failfn();
     println!("{:?}", x);
 }
diff --git a/src/test/run-fail/unwind-partial-unique.rs b/src/test/run-fail/unwind-partial-unique.rs
index f265655e0ef..8d5fcfff963 100644
--- a/src/test/run-fail/unwind-partial-unique.rs
+++ b/src/test/run-fail/unwind-partial-unique.rs
@@ -22,7 +22,7 @@ fn prime() {
 }
 
 fn partial() {
-    let _x = ~f();
+    let _x = box f();
 }
 
 fn main() {
diff --git a/src/test/run-fail/unwind-unique.rs b/src/test/run-fail/unwind-unique.rs
index 53b2a55602c..af1e499d1f2 100644
--- a/src/test/run-fail/unwind-unique.rs
+++ b/src/test/run-fail/unwind-unique.rs
@@ -10,11 +10,12 @@
 
 // error-pattern:fail
 
+
 fn failfn() {
     fail!();
 }
 
 fn main() {
-    ~0;
+    box 0;
     failfn();
 }
diff --git a/src/test/run-pass/alignment-gep-tup-like-1.rs b/src/test/run-pass/alignment-gep-tup-like-1.rs
index 2c71d791cd4..0af2be8ab29 100644
--- a/src/test/run-pass/alignment-gep-tup-like-1.rs
+++ b/src/test/run-pass/alignment-gep-tup-like-1.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 struct pair<A,B> {
     a: A, b: B
 }
@@ -27,11 +28,11 @@ impl<A:Clone> Invokable<A> for Invoker<A> {
     }
 }
 
-fn f<A:Clone + 'static>(a: A, b: u16) -> ~Invokable<A>: {
-    ~Invoker {
+fn f<A:Clone + 'static>(a: A, b: u16) -> Box<Invokable<A>:> {
+    box Invoker {
         a: a,
         b: b,
-    } as ~Invokable<A>:
+    } as Box<Invokable<A>>:
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/assert-eq-macro-success.rs b/src/test/run-pass/assert-eq-macro-success.rs
index 1e0418d8806..4aea57871b9 100644
--- a/src/test/run-pass/assert-eq-macro-success.rs
+++ b/src/test/run-pass/assert-eq-macro-success.rs
@@ -14,7 +14,7 @@ struct Point { x : int }
 pub fn main() {
     assert_eq!(14,14);
     assert_eq!("abc".to_owned(),"abc".to_owned());
-    assert_eq!(~Point{x:34},~Point{x:34});
+    assert_eq!(box Point{x:34},box Point{x:34});
     assert_eq!(&Point{x:34},&Point{x:34});
     assert_eq!(@Point{x:34},@Point{x:34});
 }
diff --git a/src/test/run-pass/auto-ref-slice-plus-ref.rs b/src/test/run-pass/auto-ref-slice-plus-ref.rs
index 2c3e6c6f04e..626f19b5108 100644
--- a/src/test/run-pass/auto-ref-slice-plus-ref.rs
+++ b/src/test/run-pass/auto-ref-slice-plus-ref.rs
@@ -26,8 +26,6 @@ impl<'a> MyIter for &'a str {
 }
 
 pub fn main() {
-    // NB: Associativity of ~, etc. in this context is surprising. These must be parenthesized
-
     ([1]).test_imm();
     (vec!(1)).as_slice().test_imm();
     (&[1]).test_imm();
diff --git a/src/test/run-pass/autoderef-method-on-trait.rs b/src/test/run-pass/autoderef-method-on-trait.rs
index 6f0bba72025..e50825a401f 100644
--- a/src/test/run-pass/autoderef-method-on-trait.rs
+++ b/src/test/run-pass/autoderef-method-on-trait.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 trait double {
     fn double(~self) -> uint;
 }
@@ -17,6 +18,6 @@ impl double for uint {
 }
 
 pub fn main() {
-    let x = ~(~3u as ~double);
+    let x = box() (box 3u as Box<double>);
     assert_eq!(x.double(), 6u);
 }
diff --git a/src/test/run-pass/autoderef-method-twice-but-not-thrice.rs b/src/test/run-pass/autoderef-method-twice-but-not-thrice.rs
index a03ac80a3f1..7acd54788a8 100644
--- a/src/test/run-pass/autoderef-method-twice-but-not-thrice.rs
+++ b/src/test/run-pass/autoderef-method-twice-but-not-thrice.rs
@@ -8,15 +8,16 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 trait double {
     fn double(~self) -> uint;
 }
 
-impl double for ~uint {
+impl double for Box<uint> {
     fn double(~self) -> uint { **self * 2u }
 }
 
 pub fn main() {
-    let x = ~~~~~3u;
+    let x = box box box box box 3u;
     assert_eq!(x.double(), 6u);
 }
diff --git a/src/test/run-pass/autoderef-method-twice.rs b/src/test/run-pass/autoderef-method-twice.rs
index 7835eaae510..a8b6b6f74f4 100644
--- a/src/test/run-pass/autoderef-method-twice.rs
+++ b/src/test/run-pass/autoderef-method-twice.rs
@@ -17,6 +17,6 @@ impl double for uint {
 }
 
 pub fn main() {
-    let x = ~~3u;
+    let x = box box 3u;
     assert_eq!(x.double(), 6u);
 }
diff --git a/src/test/run-pass/autoderef-method.rs b/src/test/run-pass/autoderef-method.rs
index 81469e5454a..4c4ebdc94f0 100644
--- a/src/test/run-pass/autoderef-method.rs
+++ b/src/test/run-pass/autoderef-method.rs
@@ -17,6 +17,6 @@ impl double for uint {
 }
 
 pub fn main() {
-    let x = ~3u;
+    let x = box 3u;
     assert_eq!(x.double(), 6u);
 }
diff --git a/src/test/run-pass/bitv-perf-test.rs b/src/test/run-pass/bitv-perf-test.rs
index 658c888b8d8..0f114969420 100644
--- a/src/test/run-pass/bitv-perf-test.rs
+++ b/src/test/run-pass/bitv-perf-test.rs
@@ -13,8 +13,8 @@ extern crate collections;
 use collections::Bitv;
 
 fn bitv_test() {
-    let mut v1 = ~Bitv::new(31, false);
-    let v2 = ~Bitv::new(31, true);
+    let mut v1 = box Bitv::new(31, false);
+    let v2 = box Bitv::new(31, true);
     v1.union(v2);
 }
 
diff --git a/src/test/run-pass/borrowck-borrow-from-expr-block.rs b/src/test/run-pass/borrowck-borrow-from-expr-block.rs
index 66b9d0430a1..2db2f8c16e0 100644
--- a/src/test/run-pass/borrowck-borrow-from-expr-block.rs
+++ b/src/test/run-pass/borrowck-borrow-from-expr-block.rs
@@ -10,11 +10,12 @@
 
 #![feature(managed_boxes)]
 
+
 fn borrow(x: &int, f: |x: &int|) {
     f(x)
 }
 
-fn test1(x: @~int) {
+fn test1(x: @Box<int>) {
     borrow(&*(*x).clone(), |p| {
         let x_a = &**x as *int;
         assert!((x_a as uint) != (p as *int as uint));
@@ -23,5 +24,5 @@ fn test1(x: @~int) {
 }
 
 pub fn main() {
-    test1(@~22);
+    test1(@box 22);
 }
diff --git a/src/test/run-pass/borrowck-lend-args.rs b/src/test/run-pass/borrowck-lend-args.rs
index a912e1ef65c..68d1b74e201 100644
--- a/src/test/run-pass/borrowck-lend-args.rs
+++ b/src/test/run-pass/borrowck-lend-args.rs
@@ -8,17 +8,18 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 fn borrow(_v: &int) {}
 
-fn borrow_from_arg_imm_ref(v: ~int) {
+fn borrow_from_arg_imm_ref(v: Box<int>) {
     borrow(v);
 }
 
-fn borrow_from_arg_mut_ref(v: &mut ~int) {
+fn borrow_from_arg_mut_ref(v: &mut Box<int>) {
     borrow(*v);
 }
 
-fn borrow_from_arg_copy(v: ~int) {
+fn borrow_from_arg_copy(v: Box<int>) {
     borrow(v);
 }
 
diff --git a/src/test/run-pass/borrowck-macro-interaction-issue-6304.rs b/src/test/run-pass/borrowck-macro-interaction-issue-6304.rs
index 881a5b4d3f6..10835730fa5 100644
--- a/src/test/run-pass/borrowck-macro-interaction-issue-6304.rs
+++ b/src/test/run-pass/borrowck-macro-interaction-issue-6304.rs
@@ -13,24 +13,25 @@
 
 #![feature(macro_rules)]
 
+
 struct Foo {
   a: int
 }
 
 pub enum Bar {
-  Bar1, Bar2(int, ~Bar),
+  Bar1, Bar2(int, Box<Bar>),
 }
 
 impl Foo {
-  fn elaborate_stm(&mut self, s: ~Bar) -> ~Bar {
+  fn elaborate_stm(&mut self, s: Box<Bar>) -> Box<Bar> {
     macro_rules! declare(
       ($id:expr, $rest:expr) => ({
         self.check_id($id);
-        ~Bar2($id, $rest)
+        box Bar2($id, $rest)
       })
     );
     match s {
-      ~Bar2(id, rest) => declare!(id, self.elaborate_stm(rest)),
+      box Bar2(id, rest) => declare!(id, self.elaborate_stm(rest)),
       _ => fail!()
     }
   }
diff --git a/src/test/run-pass/borrowck-move-by-capture-ok.rs b/src/test/run-pass/borrowck-move-by-capture-ok.rs
index 8ceef830948..48ddf927722 100644
--- a/src/test/run-pass/borrowck-move-by-capture-ok.rs
+++ b/src/test/run-pass/borrowck-move-by-capture-ok.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 pub fn main() {
-    let bar = ~3;
+    let bar = box 3;
     let h: proc() -> int = proc() *bar;
     assert_eq!(h(), 3);
 }
diff --git a/src/test/run-pass/borrowck-mut-uniq.rs b/src/test/run-pass/borrowck-mut-uniq.rs
index bed6fcd0091..ea849ee9829 100644
--- a/src/test/run-pass/borrowck-mut-uniq.rs
+++ b/src/test/run-pass/borrowck-mut-uniq.rs
@@ -10,7 +10,7 @@
 
 use std::mem::swap;
 
-struct Ints {sum: ~int, values: Vec<int> }
+struct Ints {sum: Box<int>, values: Vec<int> }
 
 fn add_int(x: &mut Ints, v: int) {
     *x.sum += v;
@@ -26,7 +26,7 @@ fn iter_ints(x: &Ints, f: |x: &int| -> bool) -> bool {
 }
 
 pub fn main() {
-    let mut ints = ~Ints {sum: ~0, values: Vec::new()};
+    let mut ints = box Ints {sum: box 0, values: Vec::new()};
     add_int(ints, 22);
     add_int(ints, 44);
 
diff --git a/src/test/run-pass/borrowck-uniq-via-ref.rs b/src/test/run-pass/borrowck-uniq-via-ref.rs
index d50b4f15f4e..451f9ccf5bd 100644
--- a/src/test/run-pass/borrowck-uniq-via-ref.rs
+++ b/src/test/run-pass/borrowck-uniq-via-ref.rs
@@ -8,8 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 struct Rec {
-    f: ~int,
+    f: Box<int>,
 }
 
 struct Outer {
@@ -21,12 +22,12 @@ struct Inner {
 }
 
 struct Innermost {
-    h: ~int,
+    h: Box<int>,
 }
 
 fn borrow(_v: &int) {}
 
-fn box_mut(v: &mut ~int) {
+fn box_mut(v: &mut Box<int>) {
     borrow(*v); // OK: &mut -> &imm
 }
 
@@ -38,7 +39,7 @@ fn box_mut_recs(v: &mut Outer) {
     borrow(v.f.g.h); // OK: &mut -> &imm
 }
 
-fn box_imm(v: &~int) {
+fn box_imm(v: &Box<int>) {
     borrow(*v); // OK
 }
 
diff --git a/src/test/run-pass/cancel-clean-via-immediate-rvalue-ref.rs b/src/test/run-pass/cancel-clean-via-immediate-rvalue-ref.rs
index 2b9e97be2c7..d326c20707d 100644
--- a/src/test/run-pass/cancel-clean-via-immediate-rvalue-ref.rs
+++ b/src/test/run-pass/cancel-clean-via-immediate-rvalue-ref.rs
@@ -8,10 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn foo(x: &mut ~u8) {
-    *x = ~5;
+
+fn foo(x: &mut Box<u8>) {
+    *x = box 5;
 }
 
 pub fn main() {
-    foo(&mut ~4);
+    foo(&mut box 4);
 }
diff --git a/src/test/run-pass/capturing-logging.rs b/src/test/run-pass/capturing-logging.rs
index 3859ed3a53d..e0e60289f9d 100644
--- a/src/test/run-pass/capturing-logging.rs
+++ b/src/test/run-pass/capturing-logging.rs
@@ -17,9 +17,9 @@
 extern crate log;
 extern crate native;
 
+use log::{set_logger, Logger, LogRecord};
 use std::fmt;
 use std::io::{ChanReader, ChanWriter};
-use log::{set_logger, Logger, LogRecord};
 
 struct MyWriter(ChanWriter);
 
@@ -41,7 +41,7 @@ fn main() {
     let (tx, rx) = channel();
     let (mut r, w) = (ChanReader::new(rx), ChanWriter::new(tx));
     spawn(proc() {
-        set_logger(~MyWriter(w) as ~Logger:Send);
+        set_logger(box MyWriter(w) as Box<Logger:Send>);
         debug!("debug");
         info!("info");
     });
diff --git a/src/test/run-pass/class-cast-to-trait-cross-crate-2.rs b/src/test/run-pass/class-cast-to-trait-cross-crate-2.rs
index 85c3c5d518e..c6c78283e19 100644
--- a/src/test/run-pass/class-cast-to-trait-cross-crate-2.rs
+++ b/src/test/run-pass/class-cast-to-trait-cross-crate-2.rs
@@ -10,16 +10,17 @@
 
 // aux-build:cci_class_cast.rs
 extern crate cci_class_cast;
+
 use std::to_str::ToStr;
 use cci_class_cast::kitty::cat;
 
-fn print_out(thing: ~ToStr, expected: ~str) {
+fn print_out(thing: Box<ToStr>, expected: ~str) {
   let actual = thing.to_str();
   println!("{}", actual);
   assert_eq!(actual, expected);
 }
 
 pub fn main() {
-  let nyan: ~ToStr = ~cat(0u, 2, "nyan".to_owned()) as ~ToStr;
+  let nyan: Box<ToStr> = box cat(0u, 2, "nyan".to_owned()) as Box<ToStr>;
   print_out(nyan, "nyan".to_owned());
 }
diff --git a/src/test/run-pass/class-separate-impl.rs b/src/test/run-pass/class-separate-impl.rs
index 0f1e8aa2724..417c927701d 100644
--- a/src/test/run-pass/class-separate-impl.rs
+++ b/src/test/run-pass/class-separate-impl.rs
@@ -57,13 +57,13 @@ impl fmt::Show for cat {
     }
 }
 
-fn print_out(thing: ~ToStr, expected: ~str) {
+fn print_out(thing: Box<ToStr>, expected: ~str) {
   let actual = thing.to_str();
   println!("{}", actual);
   assert_eq!(actual, expected);
 }
 
 pub fn main() {
-  let nyan: ~ToStr = ~cat(0u, 2, "nyan".to_owned()) as ~ToStr;
+  let nyan: Box<ToStr> = box cat(0u, 2, "nyan".to_owned()) as Box<ToStr>;
   print_out(nyan, "nyan".to_owned());
 }
diff --git a/src/test/run-pass/cleanup-arm-conditional.rs b/src/test/run-pass/cleanup-arm-conditional.rs
index 360f94564b7..65ad68ba702 100644
--- a/src/test/run-pass/cleanup-arm-conditional.rs
+++ b/src/test/run-pass/cleanup-arm-conditional.rs
@@ -26,8 +26,8 @@ use std::os;
 struct Test { x: int }
 
 impl Test {
-    fn get_x(&self) -> Option<~int> {
-        Some(~self.x)
+    fn get_x(&self) -> Option<Box<int>> {
+        Some(box self.x)
     }
 }
 
diff --git a/src/test/run-pass/cleanup-rvalue-during-if-and-while.rs b/src/test/run-pass/cleanup-rvalue-during-if-and-while.rs
index 1ae907065bf..89b00102081 100644
--- a/src/test/run-pass/cleanup-rvalue-during-if-and-while.rs
+++ b/src/test/run-pass/cleanup-rvalue-during-if-and-while.rs
@@ -12,6 +12,7 @@
 // This test verifies that temporaries created for `while`'s and `if`
 // conditions are dropped after the condition is evaluated.
 
+
 struct Temporary;
 
 static mut DROPPED: int = 0;
@@ -26,7 +27,7 @@ impl Temporary {
     fn do_stuff(&self) -> bool {true}
 }
 
-fn borrow() -> ~Temporary { ~Temporary }
+fn borrow() -> Box<Temporary> { box Temporary }
 
 
 pub fn main() {
diff --git a/src/test/run-pass/cleanup-rvalue-scopes.rs b/src/test/run-pass/cleanup-rvalue-scopes.rs
index f6f0da745ab..470e16b4888 100644
--- a/src/test/run-pass/cleanup-rvalue-scopes.rs
+++ b/src/test/run-pass/cleanup-rvalue-scopes.rs
@@ -111,8 +111,8 @@ pub fn main() {
     end_of_block!(AddFlags { bits: ref _x }, AddFlags(1));
     end_of_block!(&AddFlags { bits }, &AddFlags(1));
     end_of_block!((_, ref _y), (AddFlags(1), 22));
-    end_of_block!(~ref _x, ~AddFlags(1));
-    end_of_block!(~_x, ~AddFlags(1));
+    end_of_block!(box ref _x, box AddFlags(1));
+    end_of_block!(box _x, box AddFlags(1));
     end_of_block!(_, { { check_flags(0); &AddFlags(1) } });
     end_of_block!(_, &((Box { f: AddFlags(1) }).f));
     end_of_block!(_, &(([AddFlags(1)])[0]));
diff --git a/src/test/run-pass/cleanup-rvalue-temp-during-incomplete-alloc.rs b/src/test/run-pass/cleanup-rvalue-temp-during-incomplete-alloc.rs
index 8c906bf96b6..fda4a31375b 100644
--- a/src/test/run-pass/cleanup-rvalue-temp-during-incomplete-alloc.rs
+++ b/src/test/run-pass/cleanup-rvalue-temp-during-incomplete-alloc.rs
@@ -8,16 +8,16 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// Test cleanup of rvalue temporary that occurs while `~` construction
+// Test cleanup of rvalue temporary that occurs while `box` construction
 // is in progress. This scenario revealed a rather terrible bug.  The
 // ingredients are:
 //
-// 1. Partial cleanup of `~` is in scope,
+// 1. Partial cleanup of `box` is in scope,
 // 2. cleanup of return value from `get_bar()` is in scope,
 // 3. do_it() fails.
 //
 // This led to a bug because `the top-most frame that was to be
-// cleaned (which happens to be the partial cleanup of `~`) required
+// cleaned (which happens to be the partial cleanup of `box`) required
 // multiple basic blocks, which led to us dropping part of the cleanup
 // from the top-most frame.
 //
@@ -30,7 +30,7 @@ enum Conzabble {
     Bickwick(Foo)
 }
 
-struct Foo { field: ~uint }
+struct Foo { field: Box<uint> }
 
 fn do_it(x: &[uint]) -> Foo {
     fail!()
@@ -41,7 +41,7 @@ fn get_bar(x: uint) -> Vec<uint> { vec!(x * 2) }
 pub fn fails() {
     let x = 2;
     let mut y = Vec::new();
-    y.push(~Bickwick(do_it(get_bar(x).as_slice())));
+    y.push(box Bickwick(do_it(get_bar(x).as_slice())));
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/clone-with-exterior.rs b/src/test/run-pass/clone-with-exterior.rs
index 038c0418ecb..f676a6f0959 100644
--- a/src/test/run-pass/clone-with-exterior.rs
+++ b/src/test/run-pass/clone-with-exterior.rs
@@ -16,7 +16,7 @@ struct Pair {
 }
 
 pub fn main() {
-    let z = ~Pair { a : 10, b : 12};
+    let z = box Pair { a : 10, b : 12};
 
     let f: proc():Send = proc() {
         assert_eq!(z.a, 10);
diff --git a/src/test/run-pass/close-over-big-then-small-data.rs b/src/test/run-pass/close-over-big-then-small-data.rs
index c57b6fdf384..3e14d5b82c4 100644
--- a/src/test/run-pass/close-over-big-then-small-data.rs
+++ b/src/test/run-pass/close-over-big-then-small-data.rs
@@ -12,6 +12,7 @@
 // storing closure data (as we used to do), the u64 would
 // overwrite the u16.
 
+
 struct Pair<A,B> {
     a: A, b: B
 }
@@ -31,11 +32,11 @@ impl<A:Clone> Invokable<A> for Invoker<A> {
     }
 }
 
-fn f<A:Clone + 'static>(a: A, b: u16) -> ~Invokable<A>: {
-    ~Invoker {
+fn f<A:Clone + 'static>(a: A, b: u16) -> Box<Invokable<A>:> {
+    box Invoker {
         a: a,
         b: b,
-    } as ~Invokable<A>:
+    } as Box<Invokable<A>>:
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/const-bound.rs b/src/test/run-pass/const-bound.rs
index ff47f078da3..c864db33b21 100644
--- a/src/test/run-pass/const-bound.rs
+++ b/src/test/run-pass/const-bound.rs
@@ -23,5 +23,5 @@ pub fn main() {
     foo(F{field: 42});
     foo((1, 2u));
     foo(@1);*/
-    foo(~1);
+    foo(box 1);
 }
diff --git a/src/test/run-pass/empty-allocation-non-null.rs b/src/test/run-pass/empty-allocation-non-null.rs
index 9695296ec15..a6baf21549e 100644
--- a/src/test/run-pass/empty-allocation-non-null.rs
+++ b/src/test/run-pass/empty-allocation-non-null.rs
@@ -9,10 +9,10 @@
 // except according to those terms.
 
 pub fn main() {
-    assert!(Some(~()).is_some());
+    assert!(Some(box() ()).is_some());
 
     struct Foo;
-    assert!(Some(~Foo).is_some());
+    assert!(Some(box Foo).is_some());
 
     let xs: ~[()] = ~[];
     assert!(Some(xs).is_some());
diff --git a/src/test/run-pass/empty-allocation-rvalue-non-null.rs b/src/test/run-pass/empty-allocation-rvalue-non-null.rs
index a5fc8425cf6..96c5f81558e 100644
--- a/src/test/run-pass/empty-allocation-rvalue-non-null.rs
+++ b/src/test/run-pass/empty-allocation-rvalue-non-null.rs
@@ -9,5 +9,5 @@
 // except according to those terms.
 
 pub fn main() {
-    let x = *~();
+    let x = *box() ();
 }
diff --git a/src/test/run-pass/enum-nullable-const-null-with-fields.rs b/src/test/run-pass/enum-nullable-const-null-with-fields.rs
index 5defd837022..a48f3bcd59c 100644
--- a/src/test/run-pass/enum-nullable-const-null-with-fields.rs
+++ b/src/test/run-pass/enum-nullable-const-null-with-fields.rs
@@ -9,7 +9,8 @@
 // except according to those terms.
 
 use std::result::{Result,Ok};
-static C: Result<(), ~int> = Ok(());
+
+static C: Result<(), Box<int>> = Ok(());
 
 // This is because of yet another bad assertion (ICE) about the null side of a nullable enum.
 // So we won't actually compile if the bug is present, but we check the value in main anyway.
diff --git a/src/test/run-pass/explicit-self-generic.rs b/src/test/run-pass/explicit-self-generic.rs
index 30b716f75d8..ac2922e92d4 100644
--- a/src/test/run-pass/explicit-self-generic.rs
+++ b/src/test/run-pass/explicit-self-generic.rs
@@ -37,6 +37,6 @@ impl<K,V> HashMap<K,V> {
 }
 
 pub fn main() {
-    let mut m = ~linear_map::<(),()>();
+    let mut m = box linear_map::<(),()>();
     assert_eq!(m.len(), 0);
 }
diff --git a/src/test/run-pass/explicit-self-objects-uniq.rs b/src/test/run-pass/explicit-self-objects-uniq.rs
index 69ca98eb018..595bb4f6b9e 100644
--- a/src/test/run-pass/explicit-self-objects-uniq.rs
+++ b/src/test/run-pass/explicit-self-objects-uniq.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 trait Foo {
     fn f(~self);
 }
@@ -23,7 +24,7 @@ impl Foo for S {
 }
 
 pub fn main() {
-    let x = ~S { x: 3 };
-    let y = x as ~Foo;
+    let x = box S { x: 3 };
+    let y = x as Box<Foo>;
     y.f();
 }
diff --git a/src/test/run-pass/explicit-self.rs b/src/test/run-pass/explicit-self.rs
index 1076fc1662f..6c2e17046d3 100644
--- a/src/test/run-pass/explicit-self.rs
+++ b/src/test/run-pass/explicit-self.rs
@@ -67,7 +67,7 @@ trait Nus { fn f(&self); }
 impl Nus for thing { fn f(&self) {} }
 
 pub fn main() {
-    let y = ~thing(A {a: 10});
+    let y = box thing(A {a: 10});
     assert_eq!(y.clone().bar(), 10);
     assert_eq!(y.quux(), 10);
 
diff --git a/src/test/run-pass/expr-block-generic-unique1.rs b/src/test/run-pass/expr-block-generic-unique1.rs
index 95f3ff62d26..ec5013122ac 100644
--- a/src/test/run-pass/expr-block-generic-unique1.rs
+++ b/src/test/run-pass/expr-block-generic-unique1.rs
@@ -9,21 +9,20 @@
 // except according to those terms.
 
 
+type compare<'a, T> = |Box<T>, Box<T>|: 'a -> bool;
 
-type compare<'a, T> = |~T, ~T|: 'a -> bool;
-
-fn test_generic<T:Clone>(expected: ~T, eq: compare<T>) {
-    let actual: ~T = { expected.clone() };
+fn test_generic<T:Clone>(expected: Box<T>, eq: compare<T>) {
+    let actual: Box<T> = { expected.clone() };
     assert!((eq(expected, actual)));
 }
 
 fn test_box() {
-    fn compare_box(b1: ~bool, b2: ~bool) -> bool {
+    fn compare_box(b1: Box<bool>, b2: Box<bool>) -> bool {
         println!("{}", *b1);
         println!("{}", *b2);
         return *b1 == *b2;
     }
-    test_generic::<bool>(~true, compare_box);
+    test_generic::<bool>(box true, compare_box);
 }
 
 pub fn main() { test_box(); }
diff --git a/src/test/run-pass/expr-block-generic-unique2.rs b/src/test/run-pass/expr-block-generic-unique2.rs
index f45312f9e09..48e27dc449c 100644
--- a/src/test/run-pass/expr-block-generic-unique2.rs
+++ b/src/test/run-pass/expr-block-generic-unique2.rs
@@ -17,8 +17,8 @@ fn test_generic<T:Clone>(expected: T, eq: compare<T>) {
 }
 
 fn test_vec() {
-    fn compare_vec(v1: ~int, v2: ~int) -> bool { return v1 == v2; }
-    test_generic::<~int>(~1, compare_vec);
+    fn compare_vec(v1: Box<int>, v2: Box<int>) -> bool { return v1 == v2; }
+    test_generic::<Box<int>>(box 1, compare_vec);
 }
 
 pub fn main() { test_vec(); }
diff --git a/src/test/run-pass/expr-block-unique.rs b/src/test/run-pass/expr-block-unique.rs
index 6ef7ffe86fa..12777bce710 100644
--- a/src/test/run-pass/expr-block-unique.rs
+++ b/src/test/run-pass/expr-block-unique.rs
@@ -11,4 +11,4 @@
 
 
 
-pub fn main() { let x = { ~100 }; assert!((*x == 100)); }
+pub fn main() { let x = { box 100 }; assert!((*x == 100)); }
diff --git a/src/test/run-pass/expr-if-unique.rs b/src/test/run-pass/expr-if-unique.rs
index b40dc03ccfb..aa96a93cdb3 100644
--- a/src/test/run-pass/expr-if-unique.rs
+++ b/src/test/run-pass/expr-if-unique.rs
@@ -14,7 +14,7 @@
 
 // Tests for if as expressions returning boxed types
 fn test_box() {
-    let rs = if true { ~100 } else { ~101 };
+    let rs = if true { box 100 } else { box 101 };
     assert_eq!(*rs, 100);
 }
 
diff --git a/src/test/run-pass/expr-match-generic-unique1.rs b/src/test/run-pass/expr-match-generic-unique1.rs
index 991a1f449f1..e2f8f7c8ebf 100644
--- a/src/test/run-pass/expr-match-generic-unique1.rs
+++ b/src/test/run-pass/expr-match-generic-unique1.rs
@@ -9,11 +9,10 @@
 // except according to those terms.
 
 
+type compare<T> = |Box<T>, Box<T>|: 'static -> bool;
 
-type compare<T> = |~T, ~T|: 'static -> bool;
-
-fn test_generic<T:Clone>(expected: ~T, eq: compare<T>) {
-    let actual: ~T = match true {
+fn test_generic<T:Clone>(expected: Box<T>, eq: compare<T>) {
+    let actual: Box<T> = match true {
         true => { expected.clone() },
         _ => fail!("wat")
     };
@@ -21,8 +20,10 @@ fn test_generic<T:Clone>(expected: ~T, eq: compare<T>) {
 }
 
 fn test_box() {
-    fn compare_box(b1: ~bool, b2: ~bool) -> bool { return *b1 == *b2; }
-    test_generic::<bool>(~true, compare_box);
+    fn compare_box(b1: Box<bool>, b2: Box<bool>) -> bool {
+        return *b1 == *b2;
+    }
+    test_generic::<bool>(box true, compare_box);
 }
 
 pub fn main() { test_box(); }
diff --git a/src/test/run-pass/expr-match-generic-unique2.rs b/src/test/run-pass/expr-match-generic-unique2.rs
index d229672d057..a9b02a6e799 100644
--- a/src/test/run-pass/expr-match-generic-unique2.rs
+++ b/src/test/run-pass/expr-match-generic-unique2.rs
@@ -20,8 +20,8 @@ fn test_generic<T:Clone>(expected: T, eq: compare<T>) {
 }
 
 fn test_vec() {
-    fn compare_box(v1: ~int, v2: ~int) -> bool { return v1 == v2; }
-    test_generic::<~int>(~1, compare_box);
+    fn compare_box(v1: Box<int>, v2: Box<int>) -> bool { return v1 == v2; }
+    test_generic::<Box<int>>(box 1, compare_box);
 }
 
 pub fn main() { test_vec(); }
diff --git a/src/test/run-pass/expr-match-unique.rs b/src/test/run-pass/expr-match-unique.rs
index 85c6652c5aa..ca6e8799eae 100644
--- a/src/test/run-pass/expr-match-unique.rs
+++ b/src/test/run-pass/expr-match-unique.rs
@@ -9,12 +9,9 @@
 // except according to those terms.
 
 
-
-
-
 // Tests for match as expressions resulting in boxed types
 fn test_box() {
-    let res = match true { true => { ~100 }, _ => fail!() };
+    let res = match true { true => { box 100 }, _ => fail!() };
     assert_eq!(*res, 100);
 }
 
diff --git a/src/test/run-pass/fsu-moves-and-copies.rs b/src/test/run-pass/fsu-moves-and-copies.rs
index 571ef4bd7b4..0e6b857d7cf 100644
--- a/src/test/run-pass/fsu-moves-and-copies.rs
+++ b/src/test/run-pass/fsu-moves-and-copies.rs
@@ -21,9 +21,9 @@ impl NoFoo {
     fn new(x:int,y:int) -> NoFoo { NoFoo { copied: x, nocopy: ncint(y) } }
 }
 
-struct MoveFoo { copied: int, moved: ~int, }
+struct MoveFoo { copied: int, moved: Box<int>, }
 impl MoveFoo {
-    fn new(x:int,y:int) -> MoveFoo { MoveFoo { copied: x, moved: ~y } }
+    fn new(x:int,y:int) -> MoveFoo { MoveFoo { copied: x, moved: box y } }
 }
 
 struct DropNoFoo { inner: NoFoo }
@@ -59,8 +59,8 @@ fn test0() {
 
     // Case 2: Owned
     let f = DropMoveFoo::new(5, 6);
-    let b = DropMoveFoo { inner: MoveFoo { moved: ~7, ..f.inner }};
-    let c = DropMoveFoo { inner: MoveFoo { moved: ~8, ..f.inner }};
+    let b = DropMoveFoo { inner: MoveFoo { moved: box 7, ..f.inner }};
+    let c = DropMoveFoo { inner: MoveFoo { moved: box 8, ..f.inner }};
     assert_eq!(f.inner.copied,    5);
     assert_eq!(*f.inner.moved,    6);
 
@@ -75,7 +75,7 @@ fn test1() {
     // copying move-by-default fields from `f`, so it moves:
     let f = MoveFoo::new(11, 12);
 
-    let b = MoveFoo {moved: ~13, ..f};
+    let b = MoveFoo {moved: box 13, ..f};
     let c = MoveFoo {copied: 14, ..f};
     assert_eq!(b.copied,    11);
     assert_eq!(*b.moved,    13);
diff --git a/src/test/run-pass/func-arg-incomplete-pattern.rs b/src/test/run-pass/func-arg-incomplete-pattern.rs
index 6dc9ef2fa4b..5ab3930e7a3 100644
--- a/src/test/run-pass/func-arg-incomplete-pattern.rs
+++ b/src/test/run-pass/func-arg-incomplete-pattern.rs
@@ -11,9 +11,10 @@
 // Test that we do not leak when the arg pattern must drop part of the
 // argument (in this case, the `y` field).
 
+
 struct Foo {
-    x: ~uint,
-    y: ~uint,
+    x: Box<uint>,
+    y: Box<uint>,
 }
 
 fn foo(Foo {x, ..}: Foo) -> *uint {
@@ -22,9 +23,9 @@ fn foo(Foo {x, ..}: Foo) -> *uint {
 }
 
 pub fn main() {
-    let obj = ~1;
+    let obj = box 1;
     let objptr: *uint = &*obj;
-    let f = Foo {x: obj, y: ~2};
+    let f = Foo {x: obj, y: box 2};
     let xptr = foo(f);
     assert_eq!(objptr, xptr);
 }
diff --git a/src/test/run-pass/func-arg-ref-pattern.rs b/src/test/run-pass/func-arg-ref-pattern.rs
index 11df22d7433..bb4be948a5e 100644
--- a/src/test/run-pass/func-arg-ref-pattern.rs
+++ b/src/test/run-pass/func-arg-ref-pattern.rs
@@ -10,25 +10,26 @@
 
 // exec-env:RUST_POISON_ON_FREE=1
 
-// Test argument patterns where we create refs to the inside of `~`
+// Test argument patterns where we create refs to the inside of
 // boxes. Make sure that we don't free the box as we match the
 // pattern.
 
-fn getaddr(~ref x: ~uint) -> *uint {
+
+fn getaddr(box ref x: Box<uint>) -> *uint {
     let addr: *uint = &*x;
     addr
 }
 
-fn checkval(~ref x: ~uint) -> uint {
+fn checkval(box ref x: Box<uint>) -> uint {
     *x
 }
 
 pub fn main() {
-    let obj = ~1;
+    let obj = box 1;
     let objptr: *uint = &*obj;
     let xptr = getaddr(obj);
     assert_eq!(objptr, xptr);
 
-    let obj = ~22;
+    let obj = box 22;
     assert_eq!(checkval(obj), 22);
 }
diff --git a/src/test/run-pass/generic-alias-unique.rs b/src/test/run-pass/generic-alias-unique.rs
index 898d0c0ec23..f1338358903 100644
--- a/src/test/run-pass/generic-alias-unique.rs
+++ b/src/test/run-pass/generic-alias-unique.rs
@@ -9,12 +9,11 @@
 // except according to those terms.
 
 
-
 fn id<T:Send>(t: T) -> T { return t; }
 
 pub fn main() {
-    let expected = ~100;
-    let actual = id::<~int>(expected.clone());
+    let expected = box 100;
+    let actual = id::<Box<int>>(expected.clone());
     println!("{:?}", *actual);
     assert_eq!(*expected, *actual);
 }
diff --git a/src/test/run-pass/generic-exterior-unique.rs b/src/test/run-pass/generic-exterior-unique.rs
index 0820923efcf..0746c994c2a 100644
--- a/src/test/run-pass/generic-exterior-unique.rs
+++ b/src/test/run-pass/generic-exterior-unique.rs
@@ -8,9 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-struct Recbox<T> {x: ~T}
 
-fn reclift<T>(t: T) -> Recbox<T> { return Recbox {x: ~t}; }
+struct Recbox<T> {x: Box<T>}
+
+fn reclift<T>(t: T) -> Recbox<T> { return Recbox {x: box t}; }
 
 pub fn main() {
     let foo: int = 17;
diff --git a/src/test/run-pass/generic-fn-unique.rs b/src/test/run-pass/generic-fn-unique.rs
index c27aff53b67..c0b3fd5bc94 100644
--- a/src/test/run-pass/generic-fn-unique.rs
+++ b/src/test/run-pass/generic-fn-unique.rs
@@ -9,6 +9,6 @@
 // except according to those terms.
 
 
-fn f<T>(x: ~T) -> ~T { return x; }
+fn f<T>(x: Box<T>) -> Box<T> { return x; }
 
-pub fn main() { let x = f(~3); println!("{:?}", *x); }
+pub fn main() { let x = f(box 3); println!("{:?}", *x); }
diff --git a/src/test/run-pass/generic-object.rs b/src/test/run-pass/generic-object.rs
index 76db4a01829..d0a5af8e2ce 100644
--- a/src/test/run-pass/generic-object.rs
+++ b/src/test/run-pass/generic-object.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 trait Foo<T> {
     fn get(&self) -> T;
 }
@@ -23,7 +24,7 @@ impl Foo<int> for S {
 }
 
 pub fn main() {
-    let x = ~S { x: 1 };
-    let y = x as ~Foo<int>;
+    let x = box S { x: 1 };
+    let y = x as Box<Foo<int>>;
     assert_eq!(y.get(), 1);
 }
diff --git a/src/test/run-pass/generic-unique.rs b/src/test/run-pass/generic-unique.rs
index 3b817b314cf..4821b9354bf 100644
--- a/src/test/run-pass/generic-unique.rs
+++ b/src/test/run-pass/generic-unique.rs
@@ -8,11 +8,12 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 struct Triple<T> { x: T, y: T, z: T }
 
-fn box_it<T>(x: Triple<T>) -> ~Triple<T> { return ~x; }
+fn box_it<T>(x: Triple<T>) -> Box<Triple<T>> { return box x; }
 
 pub fn main() {
-    let x: ~Triple<int> = box_it::<int>(Triple{x: 1, y: 2, z: 3});
+    let x: Box<Triple<int>> = box_it::<int>(Triple{x: 1, y: 2, z: 3});
     assert_eq!(x.y, 2);
 }
diff --git a/src/test/run-pass/ifmt.rs b/src/test/run-pass/ifmt.rs
index 16b21f5f537..9227477c31e 100644
--- a/src/test/run-pass/ifmt.rs
+++ b/src/test/run-pass/ifmt.rs
@@ -40,7 +40,7 @@ pub fn main() {
     t!(format!("{:?}", 1), "1");
     t!(format!("{:?}", A), "A");
     t!(format!("{:?}", ()), "()");
-    t!(format!("{:?}", @(~1, "foo")), "@(~1, \"foo\")");
+    t!(format!("{:?}", @(box 1, "foo")), "@(box 1, \"foo\")");
 
     // Various edge cases without formats
     t!(format!(""), "");
@@ -142,7 +142,7 @@ pub fn main() {
     test_order();
 
     // make sure that format! doesn't move out of local variables
-    let a = ~3;
+    let a = box 3;
     format!("{:?}", a);
     format!("{:?}", a);
 
diff --git a/src/test/run-pass/init-res-into-things.rs b/src/test/run-pass/init-res-into-things.rs
index 4c1455e25cb..c573ca91840 100644
--- a/src/test/run-pass/init-res-into-things.rs
+++ b/src/test/run-pass/init-res-into-things.rs
@@ -73,7 +73,7 @@ fn test_tup() {
 fn test_unique() {
     let i = @Cell::new(0);
     {
-        let _a = ~r(i);
+        let _a = box r(i);
     }
     assert_eq!(i.get(), 1);
 }
diff --git a/src/test/run-pass/intrinsic-atomics.rs b/src/test/run-pass/intrinsic-atomics.rs
index b663cbfa509..8fa89303fa9 100644
--- a/src/test/run-pass/intrinsic-atomics.rs
+++ b/src/test/run-pass/intrinsic-atomics.rs
@@ -36,7 +36,7 @@ mod rusti {
 
 pub fn main() {
     unsafe {
-        let mut x = ~1;
+        let mut x = box 1;
 
         assert_eq!(rusti::atomic_load(&*x), 1);
         *x = 5;
diff --git a/src/test/run-pass/intrinsic-move-val.rs b/src/test/run-pass/intrinsic-move-val.rs
index f42d5ff2e52..5f5c1444819 100644
--- a/src/test/run-pass/intrinsic-move-val.rs
+++ b/src/test/run-pass/intrinsic-move-val.rs
@@ -19,7 +19,7 @@ mod rusti {
 
 pub fn main() {
     unsafe {
-        let x = ~1;
+        let x = box 1;
         let mut y = rusti::init();
         let mut z: *uint = transmute(&x);
         rusti::move_val_init(&mut y, x);
diff --git a/src/test/run-pass/issue-10682.rs b/src/test/run-pass/issue-10682.rs
index 461167d5ea4..f2f8b17daa2 100644
--- a/src/test/run-pass/issue-10682.rs
+++ b/src/test/run-pass/issue-10682.rs
@@ -11,10 +11,11 @@
 // Regression test for issue #10682
 // Nested `proc` usage can't use outer owned data
 
-fn work(_: ~int) {}
+
+fn work(_: Box<int>) {}
 fn foo(_: proc()) {}
 
 pub fn main() {
-  let a = ~1;
+  let a = box 1;
   foo(proc() { foo(proc() { work(a) }) })
 }
diff --git a/src/test/run-pass/issue-10767.rs b/src/test/run-pass/issue-10767.rs
index 3254f5bc35f..a30eb8120ea 100644
--- a/src/test/run-pass/issue-10767.rs
+++ b/src/test/run-pass/issue-10767.rs
@@ -8,8 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 pub fn main() {
     fn f() {
     };
-    let _: ~fn() = ~f;
+    let _: Box<fn()> = box f;
 }
diff --git a/src/test/run-pass/issue-10802.rs b/src/test/run-pass/issue-10802.rs
index b7b65c9de0a..6c4f0cc7f5f 100644
--- a/src/test/run-pass/issue-10802.rs
+++ b/src/test/run-pass/issue-10802.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 struct DroppableStruct;
 
 static mut DROPPED: bool = false;
@@ -19,19 +20,19 @@ impl Drop for DroppableStruct {
 }
 
 trait MyTrait { }
-impl MyTrait for ~DroppableStruct {}
+impl MyTrait for Box<DroppableStruct> {}
 
-struct Whatever { w: ~MyTrait }
+struct Whatever { w: Box<MyTrait> }
 impl  Whatever {
-    fn new(w: ~MyTrait) -> Whatever {
+    fn new(w: Box<MyTrait>) -> Whatever {
         Whatever { w: w }
     }
 }
 
 fn main() {
     {
-        let f = ~DroppableStruct;
-        let _a = Whatever::new(~f as ~MyTrait);
+        let f = box DroppableStruct;
+        let _a = Whatever::new(box f as Box<MyTrait>);
     }
     assert!(unsafe { DROPPED });
 }
diff --git a/src/test/run-pass/issue-11552.rs b/src/test/run-pass/issue-11552.rs
index 418bf5f0f9a..42b5bbc8623 100644
--- a/src/test/run-pass/issue-11552.rs
+++ b/src/test/run-pass/issue-11552.rs
@@ -8,22 +8,22 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 #[deriving(Clone)]
 enum Noun
 {
     Atom(int),
-    Cell(~Noun, ~Noun)
+    Cell(Box<Noun>, Box<Noun>)
 }
 
 fn fas(n: &Noun) -> Noun
 {
-    match n
-    {
-        &Cell(~Atom(2), ~Cell(ref a, _)) => (**a).clone(),
+    match n {
+        &Cell(box Atom(2), box Cell(ref a, _)) => (**a).clone(),
         _ => fail!("Invalid fas pattern")
     }
 }
 
 pub fn main() {
-    fas(&Cell(~Atom(2), ~Cell(~Atom(2), ~Atom(3))));
+    fas(&Cell(box Atom(2), box Cell(box Atom(2), box Atom(3))));
 }
diff --git a/src/test/run-pass/issue-2288.rs b/src/test/run-pass/issue-2288.rs
index 9e03023a9e9..85dd879c830 100644
--- a/src/test/run-pass/issue-2288.rs
+++ b/src/test/run-pass/issue-2288.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 trait clam<A> {
   fn chowder(&self, y: A);
 }
@@ -26,13 +27,13 @@ fn foo<A>(b: A) -> foo<A> {
     }
 }
 
-fn f<A>(x: ~clam<A>, a: A) {
+fn f<A>(x: Box<clam<A>>, a: A) {
   x.chowder(a);
 }
 
 pub fn main() {
 
   let c = foo(42);
-  let d: ~clam<int> = ~c as ~clam<int>;
+  let d: Box<clam<int>> = box c as Box<clam<int>>;
   f(d, c.x);
 }
diff --git a/src/test/run-pass/issue-2633-2.rs b/src/test/run-pass/issue-2633-2.rs
index 71a491b8a39..42170bfe832 100644
--- a/src/test/run-pass/issue-2633-2.rs
+++ b/src/test/run-pass/issue-2633-2.rs
@@ -8,11 +8,12 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn a_val(x: ~int, y: ~int) -> int {
+
+fn a_val(x: Box<int>, y: Box<int>) -> int {
     *x + *y
 }
 
 pub fn main() {
-    let z = ~22;
+    let z = box 22;
     a_val(z.clone(), z.clone());
 }
diff --git a/src/test/run-pass/issue-2718.rs b/src/test/run-pass/issue-2718.rs
index 0598fafd96e..2b1ba332841 100644
--- a/src/test/run-pass/issue-2718.rs
+++ b/src/test/run-pass/issue-2718.rs
@@ -42,7 +42,7 @@ pub mod pipes {
 
     pub fn packet<T:Send>() -> *packet<T> {
         unsafe {
-            let p: *packet<T> = cast::transmute(~Stuff{
+            let p: *packet<T> = cast::transmute(box Stuff{
                 state: empty,
                 blocked_task: None::<Task>,
                 payload: None::<T>
@@ -59,7 +59,7 @@ pub mod pipes {
 
     // We should consider moving this to ::std::unsafe, although I
     // suspect graydon would want us to use void pointers instead.
-    pub unsafe fn uniquify<T>(x: *T) -> ~T {
+    pub unsafe fn uniquify<T>(x: *T) -> Box<T> {
         cast::transmute(x)
     }
 
diff --git a/src/test/run-pass/issue-2734.rs b/src/test/run-pass/issue-2734.rs
index faf3b090312..9f337ecfe37 100644
--- a/src/test/run-pass/issue-2734.rs
+++ b/src/test/run-pass/issue-2734.rs
@@ -8,17 +8,18 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 trait hax { }
 impl<A> hax for A { }
 
-fn perform_hax<T: 'static>(x: ~T) -> ~hax: {
-    ~x as ~hax:
+fn perform_hax<T: 'static>(x: Box<T>) -> Box<hax:> {
+    box x as Box<hax:>
 }
 
 fn deadcode() {
-    perform_hax(~"deadcode".to_owned());
+    perform_hax(box "deadcode".to_owned());
 }
 
 pub fn main() {
-    let _ = perform_hax(~42);
+    let _ = perform_hax(box 42);
 }
diff --git a/src/test/run-pass/issue-2735.rs b/src/test/run-pass/issue-2735.rs
index af6dc66b95b..bdaf8ac9755 100644
--- a/src/test/run-pass/issue-2735.rs
+++ b/src/test/run-pass/issue-2735.rs
@@ -8,17 +8,18 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 trait hax { }
 impl<A> hax for A { }
 
-fn perform_hax<T: 'static>(x: ~T) -> ~hax: {
-    ~x as ~hax:
+fn perform_hax<T: 'static>(x: Box<T>) -> Box<hax:> {
+    box x as Box<hax:>
 }
 
 fn deadcode() {
-    perform_hax(~"deadcode".to_owned());
+    perform_hax(box "deadcode".to_owned());
 }
 
 pub fn main() {
-    perform_hax(~42);
+    perform_hax(box 42);
 }
diff --git a/src/test/run-pass/issue-2804.rs b/src/test/run-pass/issue-2804.rs
index 91e21dedd49..dfd34fcf591 100644
--- a/src/test/run-pass/issue-2804.rs
+++ b/src/test/run-pass/issue-2804.rs
@@ -21,7 +21,7 @@ enum object {
     int_value(i64),
 }
 
-fn lookup(table: ~json::Object, key: ~str, default: ~str) -> ~str
+fn lookup(table: Box<json::Object>, key: ~str, default: ~str) -> ~str
 {
     match table.find(&key) {
         option::Some(&json::String(ref s)) => {
diff --git a/src/test/run-pass/issue-2935.rs b/src/test/run-pass/issue-2935.rs
index aeef29acd0e..cdc41e892f9 100644
--- a/src/test/run-pass/issue-2935.rs
+++ b/src/test/run-pass/issue-2935.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 //type t = { a: int };
 // type t = { a: bool };
 type t = bool;
@@ -22,10 +23,10 @@ impl it for t {
 
 pub fn main() {
   //    let x = ({a: 4i} as it);
-  //   let y = ~({a: 4i});
-  //    let z = ~({a: 4i} as it);
-  //    let z = ~({a: true} as it);
-    let z = ~(~true as ~it);
+  //   let y = box ({a: 4i});
+  //    let z = box ({a: 4i} as it);
+  //    let z = box ({a: true} as it);
+    let z = box() (box true as Box<it>);
     //  x.f();
     // y.f();
     // (*z).f();
diff --git a/src/test/run-pass/issue-3026.rs b/src/test/run-pass/issue-3026.rs
index 6c181935205..9d18e176638 100644
--- a/src/test/run-pass/issue-3026.rs
+++ b/src/test/run-pass/issue-3026.rs
@@ -15,6 +15,6 @@ use collections::HashMap;
 
 pub fn main() {
     let mut buggy_map: HashMap<uint, &uint> = HashMap::new();
-    let x = ~1;
+    let x = box 1;
     buggy_map.insert(42, &*x);
 }
diff --git a/src/test/run-pass/issue-3290.rs b/src/test/run-pass/issue-3290.rs
index f2beda59733..00b78ee8e40 100644
--- a/src/test/run-pass/issue-3290.rs
+++ b/src/test/run-pass/issue-3290.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 pub fn main() {
-   let mut x = ~3;
+   let mut x = box 3;
    x = x;
    assert_eq!(*x, 3);
 }
diff --git a/src/test/run-pass/issue-3702.rs b/src/test/run-pass/issue-3702.rs
index 43f2e764e69..84414461e96 100644
--- a/src/test/run-pass/issue-3702.rs
+++ b/src/test/run-pass/issue-3702.rs
@@ -8,12 +8,13 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 pub fn main() {
   trait Text {
     fn to_str(&self) -> ~str;
   }
 
-  fn to_string(t: ~Text) {
+  fn to_string(t: Box<Text>) {
     println!("{}", t.to_str());
   }
 
diff --git a/src/test/run-pass/issue-3794.rs b/src/test/run-pass/issue-3794.rs
index 8cc7d275789..b08e6525ba5 100644
--- a/src/test/run-pass/issue-3794.rs
+++ b/src/test/run-pass/issue-3794.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 trait T {
     fn print(&self);
 }
@@ -31,9 +32,9 @@ fn print_s(s: &S) {
 }
 
 pub fn main() {
-    let s: ~S = ~S { s: 5 };
+    let s: Box<S> = box S { s: 5 };
     print_s(s);
-    let t: ~T = s as ~T;
+    let t: Box<T> = s as Box<T>;
     print_t(t);
 
 }
diff --git a/src/test/run-pass/issue-3878.rs b/src/test/run-pass/issue-3878.rs
index 4330663db25..1b09889c887 100644
--- a/src/test/run-pass/issue-3878.rs
+++ b/src/test/run-pass/issue-3878.rs
@@ -11,6 +11,6 @@
 #![allow(path_statement)]
 
 pub fn main() {
-    let y = ~1;
+    let y = box 1;
     y;
 }
diff --git a/src/test/run-pass/issue-4735.rs b/src/test/run-pass/issue-4735.rs
index b23158522a3..e89e661e9d8 100644
--- a/src/test/run-pass/issue-4735.rs
+++ b/src/test/run-pass/issue-4735.rs
@@ -20,12 +20,12 @@ struct NonCopyable(*c_void);
 impl Drop for NonCopyable {
     fn drop(&mut self) {
         let NonCopyable(p) = *self;
-        let _v = unsafe { transmute::<*c_void, ~int>(p) };
+        let _v = unsafe { transmute::<*c_void, Box<int>>(p) };
     }
 }
 
 pub fn main() {
-    let t = ~0;
-    let p = unsafe { transmute::<~int, *c_void>(t) };
+    let t = box 0;
+    let p = unsafe { transmute::<Box<int>, *c_void>(t) };
     let _z = NonCopyable(p);
 }
diff --git a/src/test/run-pass/issue-4759.rs b/src/test/run-pass/issue-4759.rs
index 45912039857..4b5c3566965 100644
--- a/src/test/run-pass/issue-4759.rs
+++ b/src/test/run-pass/issue-4759.rs
@@ -8,18 +8,19 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-struct T { a: ~int }
+
+struct T { a: Box<int> }
 
 trait U {
     fn f(self);
 }
 
-impl U for ~int {
+impl U for Box<int> {
     fn f(self) { }
 }
 
 pub fn main() {
-    let T { a: a } = T { a: ~0 };
+    let T { a: a } = T { a: box 0 };
     a.f();
 }
 
diff --git a/src/test/run-pass/issue-4830.rs b/src/test/run-pass/issue-4830.rs
index 168389bf2b8..7fc1c10895e 100644
--- a/src/test/run-pass/issue-4830.rs
+++ b/src/test/run-pass/issue-4830.rs
@@ -8,9 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 pub struct Scheduler {
     /// The event loop used to drive the scheduler and perform I/O
-    event_loop: ~int
+    event_loop: Box<int>
 }
 
 pub fn main() { }
diff --git a/src/test/run-pass/issue-5192.rs b/src/test/run-pass/issue-5192.rs
index 202a3cbcafa..0dd6623a349 100644
--- a/src/test/run-pass/issue-5192.rs
+++ b/src/test/run-pass/issue-5192.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 pub trait EventLoop {
 }
 
@@ -27,12 +28,12 @@ impl EventLoop for UvEventLoop {
 }
 
 pub struct Scheduler {
-    event_loop: ~EventLoop,
+    event_loop: Box<EventLoop>,
 }
 
 impl Scheduler {
 
-    pub fn new(event_loop: ~EventLoop) -> Scheduler {
+    pub fn new(event_loop: Box<EventLoop>) -> Scheduler {
         Scheduler {
             event_loop: event_loop,
         }
@@ -40,5 +41,5 @@ impl Scheduler {
 }
 
 pub fn main() {
-    let _sched = Scheduler::new(~UvEventLoop::new() as ~EventLoop);
+    let _sched = Scheduler::new(box UvEventLoop::new() as Box<EventLoop>);
 }
diff --git a/src/test/run-pass/issue-5666.rs b/src/test/run-pass/issue-5666.rs
index a6efa5954f1..a3dc1fae7f1 100644
--- a/src/test/run-pass/issue-5666.rs
+++ b/src/test/run-pass/issue-5666.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 struct Dog {
     name : ~str
 }
@@ -24,9 +25,9 @@ impl Barks for Dog {
 
 
 pub fn main() {
-    let snoopy = ~Dog{name: "snoopy".to_owned()};
-    let bubbles = ~Dog{name: "bubbles".to_owned()};
-    let barker = [snoopy as ~Barks, bubbles as ~Barks];
+    let snoopy = box Dog{name: "snoopy".to_owned()};
+    let bubbles = box Dog{name: "bubbles".to_owned()};
+    let barker = [snoopy as Box<Barks>, bubbles as Box<Barks>];
 
     for pup in barker.iter() {
         println!("{}", pup.bark());
diff --git a/src/test/run-pass/issue-5884.rs b/src/test/run-pass/issue-5884.rs
index 4a4c8a4011c..8d336c6e31b 100644
--- a/src/test/run-pass/issue-5884.rs
+++ b/src/test/run-pass/issue-5884.rs
@@ -10,17 +10,18 @@
 
 #![feature(managed_boxes)]
 
+
 pub struct Foo {
     a: int,
 }
 
 struct Bar<'a> {
-    a: ~Option<int>,
+    a: Box<Option<int>>,
     b: &'a Foo,
 }
 
 fn check(a: @Foo) {
-    let _ic = Bar{ b: a, a: ~None };
+    let _ic = Bar{ b: a, a: box None };
 }
 
 pub fn main(){}
diff --git a/src/test/run-pass/issue-6128.rs b/src/test/run-pass/issue-6128.rs
index 3694421c691..9f44f11e5c8 100644
--- a/src/test/run-pass/issue-6128.rs
+++ b/src/test/run-pass/issue-6128.rs
@@ -24,6 +24,6 @@ impl<E> Graph<int, E> for HashMap<int, int> {
 }
 
 pub fn main() {
-    let g : ~HashMap<int, int> = ~HashMap::new();
-    let _g2 : ~Graph<int,int> = g as ~Graph<int,int>;
+    let g : Box<HashMap<int,int>> = box HashMap::new();
+    let _g2 : Box<Graph<int,int>> = g as Box<Graph<int,int>>;
 }
diff --git a/src/test/run-pass/issue-6318.rs b/src/test/run-pass/issue-6318.rs
index 00a94c0cc37..4eb005f3397 100644
--- a/src/test/run-pass/issue-6318.rs
+++ b/src/test/run-pass/issue-6318.rs
@@ -8,8 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 pub enum Thing {
-    A(~Foo)
+    A(Box<Foo>)
 }
 
 pub trait Foo {}
@@ -19,7 +20,7 @@ pub struct Struct;
 impl Foo for Struct {}
 
 pub fn main() {
-    match A(~Struct as ~Foo) {
+    match A(box Struct as Box<Foo>) {
         A(_a) => 0,
     };
 }
diff --git a/src/test/run-pass/issue-6557.rs b/src/test/run-pass/issue-6557.rs
index 57224612573..7061a17dcdd 100644
--- a/src/test/run-pass/issue-6557.rs
+++ b/src/test/run-pass/issue-6557.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn foo(~(_x, _y): ~(int, int)) {}
+
+fn foo(box (_x, _y): Box<(int, int)>) {}
 
 pub fn main() {}
diff --git a/src/test/run-pass/issue-7320.rs b/src/test/run-pass/issue-7320.rs
index ccd2e807739..99ed4288a7e 100644
--- a/src/test/run-pass/issue-7320.rs
+++ b/src/test/run-pass/issue-7320.rs
@@ -8,10 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 trait Foo {
-    fn foo(~self) { bar(self as ~Foo); }
+    fn foo(~self) { bar(self as Box<Foo>); }
 }
 
-fn bar(_b: ~Foo) { }
+fn bar(_b: Box<Foo>) { }
 
 fn main() {}
diff --git a/src/test/run-pass/issue-7673-cast-generically-implemented-trait.rs b/src/test/run-pass/issue-7673-cast-generically-implemented-trait.rs
index cf1f979acb4..7cd7e70be74 100644
--- a/src/test/run-pass/issue-7673-cast-generically-implemented-trait.rs
+++ b/src/test/run-pass/issue-7673-cast-generically-implemented-trait.rs
@@ -14,11 +14,12 @@
 
 */
 
+
 pub fn main() {}
 
 trait A {}
 impl<T: 'static> A for T {}
 
-fn owned1<T: 'static>(a: T) { ~a as ~A:; } /* note `:` */
-fn owned2<T: 'static>(a: ~T) { a as ~A:; }
-fn owned3<T: 'static>(a: ~T) { ~a as ~A:; }
+fn owned1<T: 'static>(a: T) { box a as Box<A:>; } /* note `:` */
+fn owned2<T: 'static>(a: Box<T>) { a as Box<A:>; }
+fn owned3<T: 'static>(a: Box<T>) { box a as Box<A:>; }
diff --git a/src/test/run-pass/issue-8498.rs b/src/test/run-pass/issue-8498.rs
index ac95b5e7c19..770de8f5346 100644
--- a/src/test/run-pass/issue-8498.rs
+++ b/src/test/run-pass/issue-8498.rs
@@ -9,14 +9,14 @@
 // except according to those terms.
 
 pub fn main() {
-    match &[(~5,~7)] {
+    match &[(box 5,box 7)] {
         ps => {
            let (ref y, _) = ps[0];
            assert!(**y == 5);
         }
     }
 
-    match Some(&[(~5,)]) {
+    match Some(&[(box 5,)]) {
         Some(ps) => {
            let (ref y,) = ps[0];
            assert!(**y == 5);
@@ -24,7 +24,7 @@ pub fn main() {
         None => ()
     }
 
-    match Some(&[(~5,~7)]) {
+    match Some(&[(box 5,box 7)]) {
         Some(ps) => {
            let (ref y, ref z) = ps[0];
            assert!(**y == 5);
diff --git a/src/test/run-pass/issue-9129.rs b/src/test/run-pass/issue-9129.rs
index 52fc33d121d..b61263d1754 100644
--- a/src/test/run-pass/issue-9129.rs
+++ b/src/test/run-pass/issue-9129.rs
@@ -12,6 +12,7 @@
 
 #![feature(macro_rules)]
 
+
 pub trait bomb { fn boom(&self, Ident); }
 pub struct S;
 impl bomb for S { fn boom(&self, _: Ident) { } }
@@ -26,7 +27,7 @@ fn Ident_new() -> Ident {
     Ident {name: 0x6789ABCD }
 }
 
-pub fn light_fuse(fld: ~bomb) {
+pub fn light_fuse(fld: Box<bomb>) {
     int3!();
     let f = || {
         int3!();
@@ -36,6 +37,6 @@ pub fn light_fuse(fld: ~bomb) {
 }
 
 pub fn main() {
-    let b = ~S as ~bomb;
+    let b = box S as Box<bomb>;
     light_fuse(b);
 }
diff --git a/src/test/run-pass/issue-9382.rs b/src/test/run-pass/issue-9382.rs
index 3b79782878b..bba4b69ee1e 100644
--- a/src/test/run-pass/issue-9382.rs
+++ b/src/test/run-pass/issue-9382.rs
@@ -18,23 +18,23 @@
 
 
 struct Thing1<'a> {
-    baz: &'a [~int],
-    bar: ~u64,
+    baz: &'a [Box<int>],
+    bar: Box<u64>,
 }
 
 struct Thing2<'a> {
-    baz: &'a [~int],
+    baz: &'a [Box<int>],
     bar: u64,
 }
 
 pub fn main() {
     let _t1_fixed = Thing1 {
         baz: &[],
-        bar: ~32,
+        bar: box 32,
     };
     Thing1 {
         baz: Vec::new().as_slice(),
-        bar: ~32,
+        bar: box 32,
     };
     let _t2_fixed = Thing2 {
         baz: &[],
diff --git a/src/test/run-pass/kindck-owned-trait-contains-1.rs b/src/test/run-pass/kindck-owned-trait-contains-1.rs
index e4a7e7af14f..3dae50bda33 100644
--- a/src/test/run-pass/kindck-owned-trait-contains-1.rs
+++ b/src/test/run-pass/kindck-owned-trait-contains-1.rs
@@ -8,21 +8,22 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 trait repeat<A> { fn get(&self) -> A; }
 
-impl<A:Clone + 'static> repeat<A> for ~A {
+impl<A:Clone + 'static> repeat<A> for Box<A> {
     fn get(&self) -> A {
         (**self).clone()
     }
 }
 
-fn repeater<A:Clone + 'static>(v: ~A) -> ~repeat<A>: {
+fn repeater<A:Clone + 'static>(v: Box<A>) -> Box<repeat<A>:> {
     // Note: owned kind is not necessary as A appears in the trait type
-    ~v as ~repeat<A>: // No
+    box v as Box<repeat<A>:> // No
 }
 
 pub fn main() {
     let x = 3;
-    let y = repeater(~x);
+    let y = repeater(box x);
     assert_eq!(x, y.get());
 }
diff --git a/src/test/run-pass/last-use-in-cap-clause.rs b/src/test/run-pass/last-use-in-cap-clause.rs
index ec26dc0b3ed..463ea0c6863 100644
--- a/src/test/run-pass/last-use-in-cap-clause.rs
+++ b/src/test/run-pass/last-use-in-cap-clause.rs
@@ -10,10 +10,11 @@
 
 // Make sure #1399 stays fixed
 
-struct A { a: ~int }
+
+struct A { a: Box<int> }
 
 fn foo() -> ||: 'static -> int {
-    let k = ~22;
+    let k = box 22;
     let _u = A {a: k.clone()};
     let result: ||: 'static -> int = || 22;
     result
diff --git a/src/test/run-pass/last-use-is-capture.rs b/src/test/run-pass/last-use-is-capture.rs
index f0149c811f0..5e892d5433e 100644
--- a/src/test/run-pass/last-use-is-capture.rs
+++ b/src/test/run-pass/last-use-is-capture.rs
@@ -10,11 +10,12 @@
 
 // Make sure #1399 stays fixed
 
-struct A { a: ~int }
+
+struct A { a: Box<int> }
 
 pub fn main() {
     fn invoke(f: ||) { f(); }
-    let k = ~22;
+    let k = box 22;
     let _u = A {a: k.clone()};
     invoke(|| println!("{:?}", k.clone()) )
 }
diff --git a/src/test/run-pass/leak-unique-as-tydesc.rs b/src/test/run-pass/leak-unique-as-tydesc.rs
index ab186d935df..b109e94b74f 100644
--- a/src/test/run-pass/leak-unique-as-tydesc.rs
+++ b/src/test/run-pass/leak-unique-as-tydesc.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-
 fn leaky<T>(_t: T) { }
 
-pub fn main() { let x = ~10; leaky::<~int>(x); }
+pub fn main() { let x = box 10; leaky::<Box<int>>(x); }
diff --git a/src/test/run-pass/match-implicit-copy-unique.rs b/src/test/run-pass/match-implicit-copy-unique.rs
index 23074894490..679fb472503 100644
--- a/src/test/run-pass/match-implicit-copy-unique.rs
+++ b/src/test/run-pass/match-implicit-copy-unique.rs
@@ -8,13 +8,14 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-struct Pair { a: ~int, b: ~int }
+
+struct Pair { a: Box<int>, b: Box<int> }
 
 pub fn main() {
-    let mut x = ~Pair {a: ~10, b: ~20};
+    let mut x = box Pair {a: box 10, b: box 20};
     match x {
-      ~Pair {a: ref mut a, b: ref mut _b} => {
-        assert!(**a == 10); *a = ~30; assert!(**a == 30);
+      box Pair {a: ref mut a, b: ref mut _b} => {
+        assert!(**a == 10); *a = box 30; assert!(**a == 30);
       }
     }
 }
diff --git a/src/test/run-pass/match-unique-bind.rs b/src/test/run-pass/match-unique-bind.rs
index 9fc3a7acf71..9fae0e30d59 100644
--- a/src/test/run-pass/match-unique-bind.rs
+++ b/src/test/run-pass/match-unique-bind.rs
@@ -9,8 +9,8 @@
 // except according to those terms.
 
 pub fn main() {
-    match ~100 {
-      ~x => {
+    match box 100 {
+      box x => {
         println!("{:?}", x);
         assert_eq!(x, 100);
       }
diff --git a/src/test/run-pass/match-value-binding-in-guard-3291.rs b/src/test/run-pass/match-value-binding-in-guard-3291.rs
index 33785b2fbb0..0e7e9be6765 100644
--- a/src/test/run-pass/match-value-binding-in-guard-3291.rs
+++ b/src/test/run-pass/match-value-binding-in-guard-3291.rs
@@ -8,7 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn foo(x: Option<~int>, b: bool) -> int {
+
+fn foo(x: Option<Box<int>>, b: bool) -> int {
     match x {
       None => { 1 }
       Some(ref x) if b => { *x.clone() }
@@ -17,8 +18,8 @@ fn foo(x: Option<~int>, b: bool) -> int {
 }
 
 pub fn main() {
-    foo(Some(~22), true);
-    foo(Some(~22), false);
+    foo(Some(box 22), true);
+    foo(Some(box 22), false);
     foo(None, true);
     foo(None, false);
 }
diff --git a/src/test/run-pass/move-1-unique.rs b/src/test/run-pass/move-1-unique.rs
index ac6dfa00f48..19153dd3742 100644
--- a/src/test/run-pass/move-1-unique.rs
+++ b/src/test/run-pass/move-1-unique.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 #[deriving(Clone)]
 struct Triple {
     x: int,
@@ -15,15 +16,15 @@ struct Triple {
     z: int,
 }
 
-fn test(x: bool, foo: ~Triple) -> int {
+fn test(x: bool, foo: Box<Triple>) -> int {
     let bar = foo;
-    let mut y: ~Triple;
-    if x { y = bar; } else { y = ~Triple{x: 4, y: 5, z: 6}; }
+    let mut y: Box<Triple>;
+    if x { y = bar; } else { y = box Triple{x: 4, y: 5, z: 6}; }
     return y.y;
 }
 
 pub fn main() {
-    let x = ~Triple{x: 1, y: 2, z: 3};
+    let x = box Triple{x: 1, y: 2, z: 3};
     assert_eq!(test(true, x.clone()), 2);
     assert_eq!(test(true, x.clone()), 2);
     assert_eq!(test(true, x.clone()), 2);
diff --git a/src/test/run-pass/move-2-unique.rs b/src/test/run-pass/move-2-unique.rs
index e3595d4ac9a..65d8281407c 100644
--- a/src/test/run-pass/move-2-unique.rs
+++ b/src/test/run-pass/move-2-unique.rs
@@ -11,4 +11,8 @@
 
 struct X { x: int, y: int, z: int }
 
-pub fn main() { let x = ~X{x: 1, y: 2, z: 3}; let y = x; assert!((y.y == 2)); }
+pub fn main() {
+    let x = box X{x: 1, y: 2, z: 3};
+    let y = x;
+    assert!((y.y == 2));
+}
diff --git a/src/test/run-pass/move-3-unique.rs b/src/test/run-pass/move-3-unique.rs
index 867f00aff53..19778425367 100644
--- a/src/test/run-pass/move-3-unique.rs
+++ b/src/test/run-pass/move-3-unique.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 #[deriving(Clone)]
 struct Triple {
     x: int,
@@ -15,15 +16,15 @@ struct Triple {
     z: int,
 }
 
-fn test(x: bool, foo: ~Triple) -> int {
+fn test(x: bool, foo: Box<Triple>) -> int {
     let bar = foo;
-    let mut y: ~Triple;
-    if x { y = bar; } else { y = ~Triple {x: 4, y: 5, z: 6}; }
+    let mut y: Box<Triple>;
+    if x { y = bar; } else { y = box Triple {x: 4, y: 5, z: 6}; }
     return y.y;
 }
 
 pub fn main() {
-    let x = ~Triple{x: 1, y: 2, z: 3};
+    let x = box Triple{x: 1, y: 2, z: 3};
     for _ in range(0u, 10000u) {
         assert_eq!(test(true, x.clone()), 2);
     }
diff --git a/src/test/run-pass/move-4-unique.rs b/src/test/run-pass/move-4-unique.rs
index 60537d99d84..286781a4822 100644
--- a/src/test/run-pass/move-4-unique.rs
+++ b/src/test/run-pass/move-4-unique.rs
@@ -8,9 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 struct Triple {a: int, b: int, c: int}
 
-fn test(foo: ~Triple) -> ~Triple {
+fn test(foo: Box<Triple>) -> Box<Triple> {
     let foo = foo;
     let bar = foo;
     let baz = bar;
@@ -18,4 +19,8 @@ fn test(foo: ~Triple) -> ~Triple {
     return quux;
 }
 
-pub fn main() { let x = ~Triple{a: 1, b: 2, c: 3}; let y = test(x); assert!((y.c == 3)); }
+pub fn main() {
+    let x = box Triple{a: 1, b: 2, c: 3};
+    let y = test(x);
+    assert!((y.c == 3));
+}
diff --git a/src/test/run-pass/move-arg-2-unique.rs b/src/test/run-pass/move-arg-2-unique.rs
index 6bc3605156c..ac90f8f6ecf 100644
--- a/src/test/run-pass/move-arg-2-unique.rs
+++ b/src/test/run-pass/move-arg-2-unique.rs
@@ -9,13 +9,13 @@
 // except according to those terms.
 
 
-fn test(foo: ~Vec<int> ) { assert!((*foo.get(0) == 10)); }
+fn test(foo: Box<Vec<int>> ) { assert!((*foo.get(0) == 10)); }
 
 pub fn main() {
-    let x = ~vec!(10);
+    let x = box vec!(10);
     // Test forgetting a local by move-in
     test(x);
 
     // Test forgetting a temporary by move-in.
-    test(~vec!(10));
+    test(box vec!(10));
 }
diff --git a/src/test/run-pass/mut-function-arguments.rs b/src/test/run-pass/mut-function-arguments.rs
index 5801ccebb0f..39441227f60 100644
--- a/src/test/run-pass/mut-function-arguments.rs
+++ b/src/test/run-pass/mut-function-arguments.rs
@@ -8,20 +8,21 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn f(mut y: ~int) {
+
+fn f(mut y: Box<int>) {
     *y = 5;
     assert_eq!(*y, 5);
 }
 
 fn g() {
-    let frob: |~int| = |mut q| { *q = 2; assert!(*q == 2); };
-    let w = ~37;
+    let frob: |Box<int>| = |mut q| { *q = 2; assert!(*q == 2); };
+    let w = box 37;
     frob(w);
 
 }
 
 pub fn main() {
-    let z = ~17;
+    let z = box 17;
     f(z);
     g();
 }
diff --git a/src/test/run-pass/new-box-syntax.rs b/src/test/run-pass/new-box-syntax.rs
index 7a90ea436e0..cab3f36a9f4 100644
--- a/src/test/run-pass/new-box-syntax.rs
+++ b/src/test/run-pass/new-box-syntax.rs
@@ -14,7 +14,7 @@
 // Tests that the new `box` syntax works with unique pointers and GC pointers.
 
 use std::gc::Gc;
-use std::owned::HEAP;
+use std::owned::{Box, HEAP};
 
 struct Structure {
     x: int,
@@ -22,14 +22,14 @@ struct Structure {
 }
 
 pub fn main() {
-    let x: ~int = box(HEAP) 2;
-    let y: ~int = box 2;
+    let x: Box<int> = box(HEAP) 2;
+    let y: Box<int> = box 2;
     let z: Gc<int> = box(GC) 2;
     let a: Gc<Structure> = box(GC) Structure {
         x: 10,
         y: 20,
     };
-    let b: ~int = box()(1 + 2);
+    let b: Box<int> = box()(1 + 2);
     let c = box()(3 + 4);
     let d = box(GC)(5 + 6);
 }
diff --git a/src/test/run-pass/new-box.rs b/src/test/run-pass/new-box.rs
index 0202695841e..d41896ffb41 100644
--- a/src/test/run-pass/new-box.rs
+++ b/src/test/run-pass/new-box.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::owned::Box;
 
 fn f(x: Box<int>) {
     let y: &int = x;
diff --git a/src/test/run-pass/nullable-pointer-iotareduction.rs b/src/test/run-pass/nullable-pointer-iotareduction.rs
index 237212e7eb7..04b2e94f1a0 100644
--- a/src/test/run-pass/nullable-pointer-iotareduction.rs
+++ b/src/test/run-pass/nullable-pointer-iotareduction.rs
@@ -74,7 +74,7 @@ macro_rules! check_type {
 
 pub fn main() {
     check_type!(&17: &int);
-    check_type!(~18: ~int);
+    check_type!(box 18: Box<int>);
     check_type!(@19: @int);
     check_type!("foo".to_owned(): ~str);
     check_type!(vec!(20, 22): Vec<int> );
diff --git a/src/test/run-pass/nullable-pointer-size.rs b/src/test/run-pass/nullable-pointer-size.rs
index 4e5627237fb..00edcd6a092 100644
--- a/src/test/run-pass/nullable-pointer-size.rs
+++ b/src/test/run-pass/nullable-pointer-size.rs
@@ -38,7 +38,7 @@ macro_rules! check_type {
 
 pub fn main() {
     check_type!(&'static int);
-    check_type!(~int);
+    check_type!(Box<int>);
     check_type!(@int);
     check_type!(~str);
     check_type!(extern fn());
diff --git a/src/test/run-pass/objects-owned-object-borrowed-method-header.rs b/src/test/run-pass/objects-owned-object-borrowed-method-header.rs
index c39e79e0528..456a5c5d297 100644
--- a/src/test/run-pass/objects-owned-object-borrowed-method-header.rs
+++ b/src/test/run-pass/objects-owned-object-borrowed-method-header.rs
@@ -14,7 +14,7 @@
 
 
 // Test invoked `&self` methods on owned objects where the values
-// closed over contain managed values. This implies that the ~ boxes
+// closed over contain managed values. This implies that the boxes
 // will have headers that must be skipped over.
 
 trait FooTrait {
@@ -32,10 +32,10 @@ impl FooTrait for BarStruct {
 }
 
 pub fn main() {
-    let foos: Vec<~FooTrait:> = vec!(
-        ~BarStruct{ x: @0 } as ~FooTrait:,
-        ~BarStruct{ x: @1 } as ~FooTrait:,
-        ~BarStruct{ x: @2 } as ~FooTrait:
+    let foos: Vec<Box<FooTrait:>> = vec!(
+        box BarStruct{ x: @0 } as Box<FooTrait:>,
+        box BarStruct{ x: @1 } as Box<FooTrait:>,
+        box BarStruct{ x: @2 } as Box<FooTrait:>
     );
 
     for i in range(0u, foos.len()) {
diff --git a/src/test/run-pass/objects-owned-object-borrowed-method-headerless.rs b/src/test/run-pass/objects-owned-object-borrowed-method-headerless.rs
index bd4a933205c..9ca6598b47c 100644
--- a/src/test/run-pass/objects-owned-object-borrowed-method-headerless.rs
+++ b/src/test/run-pass/objects-owned-object-borrowed-method-headerless.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 // Test invoked `&self` methods on owned objects where the values
-// closed over do not contain managed values, and thus the ~ boxes do
+// closed over do not contain managed values, and thus the boxes do
 // not have headers.
 
 
@@ -28,10 +28,10 @@ impl FooTrait for BarStruct {
 }
 
 pub fn main() {
-    let foos: Vec<~FooTrait> = vec!(
-        ~BarStruct{ x: 0 } as ~FooTrait,
-        ~BarStruct{ x: 1 } as ~FooTrait,
-        ~BarStruct{ x: 2 } as ~FooTrait
+    let foos: Vec<Box<FooTrait>> = vec!(
+        box BarStruct{ x: 0 } as Box<FooTrait>,
+        box BarStruct{ x: 1 } as Box<FooTrait>,
+        box BarStruct{ x: 2 } as Box<FooTrait>
     );
 
     for i in range(0u, foos.len()) {
diff --git a/src/test/run-pass/objects-owned-object-owned-method.rs b/src/test/run-pass/objects-owned-object-owned-method.rs
index 0d675c16d1a..cac132b8e36 100644
--- a/src/test/run-pass/objects-owned-object-owned-method.rs
+++ b/src/test/run-pass/objects-owned-object-owned-method.rs
@@ -9,9 +9,10 @@
 // except according to those terms.
 
 // Test invoked `&self` methods on owned objects where the values
-// closed over contain managed values. This implies that the ~ boxes
+// closed over contain managed values. This implies that the boxes
 // will have headers that must be skipped over.
 
+
 trait FooTrait {
     fn foo(~self) -> uint;
 }
@@ -27,6 +28,6 @@ impl FooTrait for BarStruct {
 }
 
 pub fn main() {
-    let foo = ~BarStruct{ x: 22 } as ~FooTrait;
+    let foo = box BarStruct{ x: 22 } as Box<FooTrait:>;
     assert_eq!(22, foo.foo());
 }
diff --git a/src/test/run-pass/overloaded-autoderef.rs b/src/test/run-pass/overloaded-autoderef.rs
index 08cb2f57990..39566cbc6ed 100644
--- a/src/test/run-pass/overloaded-autoderef.rs
+++ b/src/test/run-pass/overloaded-autoderef.rs
@@ -20,7 +20,7 @@ struct Point {
 
 pub fn main() {
     assert_eq!(Rc::new(5u).to_uint(), Some(5));
-    assert_eq!((~&~&Rc::new(~~&~5u)).to_uint(), Some(5));
+    assert_eq!((box &box &Rc::new(box box &box 5u)).to_uint(), Some(5));
     let point = Rc::new(Point {x: 2, y: 4});
     assert_eq!(point.x, 2);
     assert_eq!(point.y, 4);
diff --git a/src/test/run-pass/overloaded-deref.rs b/src/test/run-pass/overloaded-deref.rs
index 5328b213810..47cdc8d247a 100644
--- a/src/test/run-pass/overloaded-deref.rs
+++ b/src/test/run-pass/overloaded-deref.rs
@@ -20,7 +20,7 @@ struct Point {
 
 pub fn main() {
     assert_eq!(*Rc::new(5), 5);
-    assert_eq!(***Rc::new(~~5), 5);
+    assert_eq!(***Rc::new(box box 5), 5);
     assert_eq!(*Rc::new(Point {x: 2, y: 4}), Point {x: 2, y: 4});
 
     let i = Rc::new(RefCell::new(2));
diff --git a/src/test/run-pass/owned-implies-static.rs b/src/test/run-pass/owned-implies-static.rs
index f327f6bc0dc..d1e9fb270d7 100644
--- a/src/test/run-pass/owned-implies-static.rs
+++ b/src/test/run-pass/owned-implies-static.rs
@@ -11,5 +11,5 @@
 fn f<T: 'static>(_x: T) {}
 
 pub fn main() {
-    f(~5);
+    f(box 5);
 }
diff --git a/src/test/run-pass/parameterized-trait-with-bounds.rs b/src/test/run-pass/parameterized-trait-with-bounds.rs
index e22bc4247e0..6f33fb470e7 100644
--- a/src/test/run-pass/parameterized-trait-with-bounds.rs
+++ b/src/test/run-pass/parameterized-trait-with-bounds.rs
@@ -10,6 +10,7 @@
 
 #![allow(dead_code)]
 
+
 trait A<T> {}
 trait B<T, U> {}
 trait C<'a, U> {}
@@ -19,9 +20,9 @@ mod foo {
 }
 
 fn foo1<T>(_: &A<T>: Send) {}
-fn foo2<T>(_: ~A<T>: Send + Share) {}
-fn foo3<T>(_: ~B<int, uint>: 'static) {}
-fn foo4<'a, T>(_: ~C<'a, T>: 'static + Send) {}
-fn foo5<'a, T>(_: ~foo::D<'a, T>: 'static + Send) {}
+fn foo2<T>(_: Box<A<T>: Send + Share>) {}
+fn foo3<T>(_: Box<B<int, uint>: 'static>) {}
+fn foo4<'a, T>(_: Box<C<'a, T>: 'static + Send>) {}
+fn foo5<'a, T>(_: Box<foo::D<'a, T>: 'static + Send>) {}
 
 pub fn main() {}
diff --git a/src/test/run-pass/privacy-ns.rs b/src/test/run-pass/privacy-ns.rs
index 0756d8214a6..5915b3e3a76 100644
--- a/src/test/run-pass/privacy-ns.rs
+++ b/src/test/run-pass/privacy-ns.rs
@@ -16,6 +16,7 @@
 #![allow(dead_code)]
 #![allow(unused_imports)]
 
+
 // public type, private value
 pub mod foo1 {
     pub trait Bar {
@@ -34,19 +35,19 @@ fn test_unused1() {
 fn test_single1() {
     use foo1::Bar;
 
-    let _x: ~Bar;
+    let _x: Box<Bar>;
 }
 
 fn test_list1() {
     use foo1::{Bar,Baz};
 
-    let _x: ~Bar;
+    let _x: Box<Bar>;
 }
 
 fn test_glob1() {
     use foo1::*;
 
-    let _x: ~Bar;
+    let _x: Box<Bar>;
 }
 
 // private type, public value
@@ -101,21 +102,21 @@ fn test_single3() {
     use foo3::Bar;
 
     Bar();
-    let _x: ~Bar;
+    let _x: Box<Bar>;
 }
 
 fn test_list3() {
     use foo3::{Bar,Baz};
 
     Bar();
-    let _x: ~Bar;
+    let _x: Box<Bar>;
 }
 
 fn test_glob3() {
     use foo3::*;
 
     Bar();
-    let _x: ~Bar;
+    let _x: Box<Bar>;
 }
 
 fn main() {
diff --git a/src/test/run-pass/pure-sum.rs b/src/test/run-pass/pure-sum.rs
index ef569af1350..60eb3f9debd 100644
--- a/src/test/run-pass/pure-sum.rs
+++ b/src/test/run-pass/pure-sum.rs
@@ -23,7 +23,7 @@ fn sums_to(v: Vec<int> , sum: int) -> bool {
 
 fn sums_to_using_uniq(v: Vec<int> , sum: int) -> bool {
     let mut i = 0u;
-    let mut sum0 = ~0;
+    let mut sum0 = box 0;
     while i < v.len() {
         *sum0 += *v.get(i);
         i += 1u;
@@ -45,7 +45,7 @@ struct F<T> { f: T }
 
 fn sums_to_using_uniq_rec(v: Vec<int> , sum: int) -> bool {
     let mut i = 0u;
-    let mut sum0 = F {f: ~0};
+    let mut sum0 = F {f: box 0};
     while i < v.len() {
         *sum0.f += *v.get(i);
         i += 1u;
diff --git a/src/test/run-pass/rcvr-borrowed-to-region.rs b/src/test/run-pass/rcvr-borrowed-to-region.rs
index 4b54c32fbd3..eab5ba61083 100644
--- a/src/test/run-pass/rcvr-borrowed-to-region.rs
+++ b/src/test/run-pass/rcvr-borrowed-to-region.rs
@@ -33,7 +33,7 @@ pub fn main() {
     println!("y={}", y);
     assert_eq!(y, 6);
 
-    let x = ~6;
+    let x = box 6;
     let y = x.get();
     println!("y={}", y);
     assert_eq!(y, 6);
diff --git a/src/test/run-pass/regions-addr-of-interior-of-unique-box.rs b/src/test/run-pass/regions-addr-of-interior-of-unique-box.rs
index 7efe62236f3..47ae5c13d28 100644
--- a/src/test/run-pass/regions-addr-of-interior-of-unique-box.rs
+++ b/src/test/run-pass/regions-addr-of-interior-of-unique-box.rs
@@ -8,13 +8,14 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 struct Point {
     x: int,
     y: int
 }
 
 struct Character {
-    pos: ~Point
+    pos: Box<Point>,
 }
 
 fn get_x<'r>(x: &'r Character) -> &'r int {
diff --git a/src/test/run-pass/regions-borrow-uniq.rs b/src/test/run-pass/regions-borrow-uniq.rs
index 10037d9dfe4..6b35c0768d7 100644
--- a/src/test/run-pass/regions-borrow-uniq.rs
+++ b/src/test/run-pass/regions-borrow-uniq.rs
@@ -13,7 +13,7 @@ fn foo(x: &uint) -> uint {
 }
 
 pub fn main() {
-    let p = ~3u;
+    let p = box 3u;
     let r = foo(p);
     assert_eq!(r, 3u);
 }
diff --git a/src/test/run-pass/regions-bound-lists-feature-gate.rs b/src/test/run-pass/regions-bound-lists-feature-gate.rs
index 163e6670c9c..3e23c1d4d64 100644
--- a/src/test/run-pass/regions-bound-lists-feature-gate.rs
+++ b/src/test/run-pass/regions-bound-lists-feature-gate.rs
@@ -12,9 +12,10 @@
 
 #![feature(issue_5723_bootstrap)]
 
+
 trait Foo { }
 
-fn foo<'a>(x: ~Foo:'a) {
+fn foo<'a>(x: Box<Foo:'a>) {
 }
 
 fn bar<'a, T:'a>() {
diff --git a/src/test/run-pass/regions-dependent-addr-of.rs b/src/test/run-pass/regions-dependent-addr-of.rs
index 256d12ccddf..400ab462f76 100644
--- a/src/test/run-pass/regions-dependent-addr-of.rs
+++ b/src/test/run-pass/regions-dependent-addr-of.rs
@@ -21,7 +21,7 @@ struct B {
     v2: [int, ..3],
     v3: Vec<int> ,
     v4: C,
-    v5: ~C,
+    v5: Box<C>,
     v6: Option<C>
 }
 
@@ -78,7 +78,7 @@ fn get_v6_c<'v>(a: &'v A, _i: uint) -> &'v int {
 
 fn get_v5_ref<'v>(a: &'v A, _i: uint) -> &'v int {
     match &a.value {
-        &B {v5: ~C {f: ref v}, ..} => v
+        &B {v5: box C {f: ref v}, ..} => v
     }
 }
 
@@ -87,7 +87,7 @@ pub fn main() {
                          v2: [23, 24, 25],
                          v3: vec!(26, 27, 28),
                          v4: C { f: 29 },
-                         v5: ~C { f: 30 },
+                         v5: box C { f: 30 },
                          v6: Some(C { f: 31 })}};
 
     let p = get_v1(&a);
diff --git a/src/test/run-pass/regions-early-bound-trait-param.rs b/src/test/run-pass/regions-early-bound-trait-param.rs
index f3cfa0b9d33..a7ba496dc4a 100644
--- a/src/test/run-pass/regions-early-bound-trait-param.rs
+++ b/src/test/run-pass/regions-early-bound-trait-param.rs
@@ -11,6 +11,7 @@
 // Tests that you can use an early-bound lifetime parameter as
 // on of the generic parameters in a trait.
 
+
 trait Trait<'a> {
     fn long(&'a self) -> int;
     fn short<'b>(&'b self) -> int;
@@ -77,8 +78,8 @@ impl<'s> Trait<'s> for (int,int) {
     }
 }
 
-impl<'t> MakerTrait<'t> for ~Trait<'t> {
-    fn mk() -> ~Trait<'t> { ~(4,5) as ~Trait }
+impl<'t> MakerTrait<'t> for Box<Trait<'t>> {
+    fn mk() -> Box<Trait<'t>> { box() (4,5) as Box<Trait> }
 }
 
 enum List<'l> {
@@ -118,7 +119,7 @@ pub fn main() {
     assert_eq!(object_invoke2(&t), 3);
     assert_eq!(field_invoke2(&s2), 3);
 
-    let m : ~Trait = make_val();
+    let m : Box<Trait> = make_val();
     assert_eq!(object_invoke1(m), (4,5));
     assert_eq!(object_invoke2(m), 5);
 
diff --git a/src/test/run-pass/self-in-mut-slot-default-method.rs b/src/test/run-pass/self-in-mut-slot-default-method.rs
index 08d10fd1170..8ab27cfb4ee 100644
--- a/src/test/run-pass/self-in-mut-slot-default-method.rs
+++ b/src/test/run-pass/self-in-mut-slot-default-method.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 struct X {
     a: int
 }
@@ -18,7 +19,7 @@ trait Changer {
         self
     }
 
-    fn change_again(mut ~self) -> ~Self {
+    fn change_again(mut ~self) -> Box<Self> {
         self.set_to(45);
         self
     }
@@ -37,7 +38,7 @@ pub fn main() {
     let new_x = x.change();
     assert_eq!(new_x.a, 55);
 
-    let x = ~new_x;
+    let x = box new_x;
     let new_x = x.change_again();
     assert_eq!(new_x.a, 45);
 }
diff --git a/src/test/run-pass/self-re-assign.rs b/src/test/run-pass/self-re-assign.rs
index 4e1a9b665d0..e613a83737e 100644
--- a/src/test/run-pass/self-re-assign.rs
+++ b/src/test/run-pass/self-re-assign.rs
@@ -14,7 +14,7 @@
 use std::rc::Rc;
 
 pub fn main() {
-   let mut x = ~3;
+   let mut x = box 3;
    x = x;
    assert!(*x == 3);
 
diff --git a/src/test/run-pass/sendfn-spawn-with-fn-arg.rs b/src/test/run-pass/sendfn-spawn-with-fn-arg.rs
index a62c1ec3314..c03094d4f15 100644
--- a/src/test/run-pass/sendfn-spawn-with-fn-arg.rs
+++ b/src/test/run-pass/sendfn-spawn-with-fn-arg.rs
@@ -17,7 +17,7 @@ fn test05_start(f: proc(int)) {
 }
 
 fn test05() {
-    let three = ~3;
+    let three = box 3;
     let fn_to_send: proc(int):Send = proc(n) {
         println!("{}", *three + n); // will copy x into the closure
         assert_eq!(*three, 3);
diff --git a/src/test/run-pass/sized-owned-pointer.rs b/src/test/run-pass/sized-owned-pointer.rs
index 0c05fdd616b..e64917a97a6 100644
--- a/src/test/run-pass/sized-owned-pointer.rs
+++ b/src/test/run-pass/sized-owned-pointer.rs
@@ -10,6 +10,7 @@
 
 // Possibly-dynamic size of typaram should be cleared at pointer boundary.
 
+
 fn bar<T: Sized>() { }
-fn foo<T>() { bar::<~T>() }
+fn foo<T>() { bar::<Box<T>>() }
 pub fn main() { }
diff --git a/src/test/run-pass/task-spawn-move-and-copy.rs b/src/test/run-pass/task-spawn-move-and-copy.rs
index 18d7839652a..cf6c2754829 100644
--- a/src/test/run-pass/task-spawn-move-and-copy.rs
+++ b/src/test/run-pass/task-spawn-move-and-copy.rs
@@ -13,7 +13,7 @@ use std::task;
 pub fn main() {
     let (tx, rx) = channel::<uint>();
 
-    let x = ~1;
+    let x = box 1;
     let x_in_parent = &(*x) as *int as uint;
 
     task::spawn(proc() {
diff --git a/src/test/run-pass/trait-bounds-basic.rs b/src/test/run-pass/trait-bounds-basic.rs
index 6059e5e95ee..68ebf2c6382 100644
--- a/src/test/run-pass/trait-bounds-basic.rs
+++ b/src/test/run-pass/trait-bounds-basic.rs
@@ -8,24 +8,25 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 trait Foo {
 }
 
-fn a(_x: ~Foo:) {
+fn a(_x: Box<Foo:>) {
 }
 
-fn b(_x: ~Foo:Send) {
+fn b(_x: Box<Foo:Send>) {
 }
 
-fn c(x: ~Foo:Share+Send) {
+fn c(x: Box<Foo:Share+Send>) {
     a(x);
 }
 
-fn d(x: ~Foo:Send) {
+fn d(x: Box<Foo:Send>) {
     b(x);
 }
 
-fn e(x: ~Foo) { // sugar for ~Foo:Owned
+fn e(x: Box<Foo>) { // sugar for Box<Foo:Owned>
     a(x);
 }
 
diff --git a/src/test/run-pass/trait-bounds-in-arc.rs b/src/test/run-pass/trait-bounds-in-arc.rs
index 312978f00a0..0a6e5ce0b67 100644
--- a/src/test/run-pass/trait-bounds-in-arc.rs
+++ b/src/test/run-pass/trait-bounds-in-arc.rs
@@ -64,10 +64,10 @@ pub fn main() {
     let dogge1 = Dogge { bark_decibels: 100, tricks_known: 42, name: "alan_turing".to_owned() };
     let dogge2 = Dogge { bark_decibels: 55,  tricks_known: 11, name: "albert_einstein".to_owned() };
     let fishe = Goldfyshe { swim_speed: 998, name: "alec_guinness".to_owned() };
-    let arc = Arc::new(vec!(~catte  as ~Pet:Share+Send,
-                         ~dogge1 as ~Pet:Share+Send,
-                         ~fishe  as ~Pet:Share+Send,
-                         ~dogge2 as ~Pet:Share+Send));
+    let arc = Arc::new(vec!(box catte  as Box<Pet:Share+Send>,
+                            box dogge1 as Box<Pet:Share+Send>,
+                            box fishe  as Box<Pet:Share+Send>,
+                            box dogge2 as Box<Pet:Share+Send>));
     let (tx1, rx1) = channel();
     let arc1 = arc.clone();
     task::spawn(proc() { check_legs(arc1); tx1.send(()); });
@@ -82,21 +82,21 @@ pub fn main() {
     rx3.recv();
 }
 
-fn check_legs(arc: Arc<Vec<~Pet:Share+Send>>) {
+fn check_legs(arc: Arc<Vec<Box<Pet:Share+Send>>>) {
     let mut legs = 0;
     for pet in arc.iter() {
         legs += pet.num_legs();
     }
     assert!(legs == 12);
 }
-fn check_names(arc: Arc<Vec<~Pet:Share+Send>>) {
+fn check_names(arc: Arc<Vec<Box<Pet:Share+Send>>>) {
     for pet in arc.iter() {
         pet.name(|name| {
             assert!(name[0] == 'a' as u8 && name[1] == 'l' as u8);
         })
     }
 }
-fn check_pedigree(arc: Arc<Vec<~Pet:Share+Send>>) {
+fn check_pedigree(arc: Arc<Vec<Box<Pet:Share+Send>>>) {
     for pet in arc.iter() {
         assert!(pet.of_good_pedigree());
     }
diff --git a/src/test/run-pass/trait-cast.rs b/src/test/run-pass/trait-cast.rs
index 244459e2269..3d303bf1e5b 100644
--- a/src/test/run-pass/trait-cast.rs
+++ b/src/test/run-pass/trait-cast.rs
@@ -18,7 +18,7 @@ struct Tree(@RefCell<TreeR>);
 struct TreeR {
     left: Option<Tree>,
     right: Option<Tree>,
-    val: ~to_str:Send
+    val: Box<to_str:Send>
 }
 
 trait to_str {
@@ -53,10 +53,10 @@ fn foo<T:to_str>(x: T) -> ~str { x.to_str_() }
 pub fn main() {
     let t1 = Tree(@RefCell::new(TreeR{left: None,
                                       right: None,
-                                      val: ~1 as ~to_str:Send}));
+                                      val: box 1 as Box<to_str:Send>}));
     let t2 = Tree(@RefCell::new(TreeR{left: Some(t1),
                                       right: Some(t1),
-                                      val: ~2 as ~to_str:Send}));
+                                      val: box 2 as Box<to_str:Send>}));
     let expected = "[2, some([1, none, none]), some([1, none, none])]".to_owned();
     assert!(t2.to_str_() == expected);
     assert!(foo(t2) == expected);
diff --git a/src/test/run-pass/trait-coercion-generic.rs b/src/test/run-pass/trait-coercion-generic.rs
index 2d8a42005df..1e241ad2278 100644
--- a/src/test/run-pass/trait-coercion-generic.rs
+++ b/src/test/run-pass/trait-coercion-generic.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 trait Trait<T> {
     fn f(&self, x: T);
 }
@@ -25,7 +26,7 @@ impl Trait<&'static str> for Struct {
 
 pub fn main() {
     let a = Struct { x: 1, y: 2 };
-    let b: ~Trait<&'static str> = ~a;
+    let b: Box<Trait<&'static str>> = box a;
     b.f("Mary");
     let c: &Trait<&'static str> = &a;
     c.f("Joe");
diff --git a/src/test/run-pass/trait-coercion.rs b/src/test/run-pass/trait-coercion.rs
index ea6d59a9068..1d229a8ae83 100644
--- a/src/test/run-pass/trait-coercion.rs
+++ b/src/test/run-pass/trait-coercion.rs
@@ -25,18 +25,18 @@ impl Trait for Struct {
     }
 }
 
-fn foo(mut a: ~Writer) {
+fn foo(mut a: Box<Writer>) {
     a.write(bytes!("Hello\n"));
 }
 
 pub fn main() {
     let a = Struct { x: 1, y: 2 };
-    let b: ~Trait = ~a;
+    let b: Box<Trait> = box a;
     b.f();
     let c: &Trait = &a;
     c.f();
 
     let out = io::stdout();
-    foo(~out);
+    foo(box out);
 }
 
diff --git a/src/test/run-pass/trait-default-method-xc.rs b/src/test/run-pass/trait-default-method-xc.rs
index 25b5b7fbd5f..27db6d2f3b8 100644
--- a/src/test/run-pass/trait-default-method-xc.rs
+++ b/src/test/run-pass/trait-default-method-xc.rs
@@ -50,7 +50,7 @@ impl TestEquality for stuff::thing {
 }
 
 
-pub fn main () {
+pub fn main() {
     // Some tests of random things
     f(0);
 
@@ -72,7 +72,7 @@ pub fn main () {
     assert_eq!(g(0i, 3.14, 1), (3.14, 1));
     assert_eq!(g(false, 3.14, 1), (3.14, 1));
 
-    let obj = ~0i as ~A;
+    let obj = box 0i as Box<A>;
     assert_eq!(obj.h(), 11);
 
 
diff --git a/src/test/run-pass/trait-object-generics.rs b/src/test/run-pass/trait-object-generics.rs
index e2422a1dcf5..3c5ae6b57a3 100644
--- a/src/test/run-pass/trait-object-generics.rs
+++ b/src/test/run-pass/trait-object-generics.rs
@@ -10,6 +10,7 @@
 
 // test for #8664
 
+
 pub trait Trait2<A> {
     fn doit(&self);
 }
@@ -20,7 +21,7 @@ pub struct Impl<A1, A2, A3> {
      * task <unnamed> failed at 'index out of bounds: the len is 1 but the index is 1',
      * src/librustc/middle/subst.rs:58
      */
-    t: ~Trait2<A2>
+    t: Box<Trait2<A2>>
 }
 
 impl<A1, A2, A3> Impl<A1, A2, A3> {
@@ -42,6 +43,6 @@ impl<V> Trait<u8,V> for () {
 }
 
 pub fn main() {
-    let a = ~() as ~Trait<u8, u8>;
+    let a = box() () as Box<Trait<u8, u8>>;
     assert_eq!(a.method(Constant), 0);
 }
diff --git a/src/test/run-pass/type-param-constraints.rs b/src/test/run-pass/type-param-constraints.rs
index 408a727b6f1..0fcf9b92ce0 100644
--- a/src/test/run-pass/type-param-constraints.rs
+++ b/src/test/run-pass/type-param-constraints.rs
@@ -8,9 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-
 #![feature(managed_boxes)]
 
+
 fn p_foo<T>(_pinned: T) { }
 fn s_foo<T>(_shared: T) { }
 fn u_foo<T:Send>(_unique: T) { }
@@ -33,16 +33,16 @@ pub fn main() {
     p_foo(r(10));
     p_foo(@r(10));
 
-    p_foo(~r(10));
+    p_foo(box r(10));
     p_foo(@10);
-    p_foo(~10);
+    p_foo(box 10);
     p_foo(10);
 
     s_foo(@r(10));
     s_foo(@10);
-    s_foo(~10);
+    s_foo(box 10);
     s_foo(10);
 
-    u_foo(~10);
+    u_foo(box 10);
     u_foo(10);
 }
diff --git a/src/test/run-pass/uniq-cc.rs b/src/test/run-pass/uniq-cc.rs
index 1c7525f0754..06e9771aae4 100644
--- a/src/test/run-pass/uniq-cc.rs
+++ b/src/test/run-pass/uniq-cc.rs
@@ -19,14 +19,14 @@ enum maybe_pointy {
 
 struct Pointy {
     a : maybe_pointy,
-    c : ~int,
+    c : Box<int>,
     d : proc():Send->(),
 }
 
 fn empty_pointy() -> @RefCell<Pointy> {
     return @RefCell::new(Pointy {
         a : none,
-        c : ~22,
+        c : box 22,
         d : proc() {},
     })
 }
diff --git a/src/test/run-pass/uniq-self-in-mut-slot.rs b/src/test/run-pass/uniq-self-in-mut-slot.rs
index 7c2f5221176..3700e02051a 100644
--- a/src/test/run-pass/uniq-self-in-mut-slot.rs
+++ b/src/test/run-pass/uniq-self-in-mut-slot.rs
@@ -8,23 +8,24 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 struct X {
     a: int
 }
 
 trait Changer {
-    fn change(mut ~self) -> ~Self;
+    fn change(mut ~self) -> Box<Self>;
 }
 
 impl Changer for X {
-    fn change(mut ~self) -> ~X {
+    fn change(mut ~self) -> Box<X> {
         self.a = 55;
         self
     }
 }
 
 pub fn main() {
-    let x = ~X { a: 32 };
+    let x = box X { a: 32 };
     let new_x = x.change();
     assert_eq!(new_x.a, 55);
 }
diff --git a/src/test/run-pass/unique-assign-copy.rs b/src/test/run-pass/unique-assign-copy.rs
index e59fe469dec..b295701d186 100644
--- a/src/test/run-pass/unique-assign-copy.rs
+++ b/src/test/run-pass/unique-assign-copy.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 pub fn main() {
-    let mut i = ~1;
+    let mut i = box 1;
     // Should be a copy
     let mut j;
     j = i.clone();
diff --git a/src/test/run-pass/unique-assign-drop.rs b/src/test/run-pass/unique-assign-drop.rs
index df8036451d8..90e5e82f0d8 100644
--- a/src/test/run-pass/unique-assign-drop.rs
+++ b/src/test/run-pass/unique-assign-drop.rs
@@ -11,8 +11,8 @@
 #![allow(dead_assignment)]
 
 pub fn main() {
-    let i = ~1;
-    let mut j = ~2;
+    let i = box 1;
+    let mut j = box 2;
     // Should drop the previous value of j
     j = i;
     assert_eq!(*j, 1);
diff --git a/src/test/run-pass/unique-assign-generic.rs b/src/test/run-pass/unique-assign-generic.rs
index 595c5fe82e7..94e3ea565d6 100644
--- a/src/test/run-pass/unique-assign-generic.rs
+++ b/src/test/run-pass/unique-assign-generic.rs
@@ -16,8 +16,8 @@ fn f<T>(t: T) -> T {
 }
 
 pub fn main() {
-    let t = f(~100);
-    assert_eq!(t, ~100);
-    let t = f(~@vec!(100));
-    assert_eq!(t, ~@vec!(100));
+    let t = f(box 100);
+    assert_eq!(t, box 100);
+    let t = f(box @vec!(100));
+    assert_eq!(t, box @vec!(100));
 }
diff --git a/src/test/run-pass/unique-assign.rs b/src/test/run-pass/unique-assign.rs
index 43df53c78a8..d332e235809 100644
--- a/src/test/run-pass/unique-assign.rs
+++ b/src/test/run-pass/unique-assign.rs
@@ -10,6 +10,6 @@
 
 pub fn main() {
     let mut i;
-    i = ~1;
+    i = box 1;
     assert_eq!(*i, 1);
 }
diff --git a/src/test/run-pass/unique-autoderef-field.rs b/src/test/run-pass/unique-autoderef-field.rs
index 6836ba4e79b..67f96decaa9 100644
--- a/src/test/run-pass/unique-autoderef-field.rs
+++ b/src/test/run-pass/unique-autoderef-field.rs
@@ -11,7 +11,7 @@
 struct J { j: int }
 
 pub fn main() {
-    let i = ~J {
+    let i = box J {
         j: 100
     };
     assert_eq!(i.j, 100);
diff --git a/src/test/run-pass/unique-autoderef-index.rs b/src/test/run-pass/unique-autoderef-index.rs
index 4971a42be30..fc5bac249ba 100644
--- a/src/test/run-pass/unique-autoderef-index.rs
+++ b/src/test/run-pass/unique-autoderef-index.rs
@@ -10,6 +10,6 @@
 
 
 pub fn main() {
-    let i = ~vec!(100);
+    let i = box vec!(100);
     assert_eq!(*i.get(0), 100);
 }
diff --git a/src/test/run-pass/unique-cmp.rs b/src/test/run-pass/unique-cmp.rs
index b50d3154835..037faee9599 100644
--- a/src/test/run-pass/unique-cmp.rs
+++ b/src/test/run-pass/unique-cmp.rs
@@ -9,10 +9,10 @@
 // except according to those terms.
 
 pub fn main() {
-    let i = ~100;
-    assert!(i == ~100);
-    assert!(i < ~101);
-    assert!(i <= ~100);
-    assert!(i > ~99);
-    assert!(i >= ~99);
+    let i = box 100;
+    assert!(i == box 100);
+    assert!(i < box 101);
+    assert!(i <= box 100);
+    assert!(i > box 99);
+    assert!(i >= box 99);
 }
diff --git a/src/test/run-pass/unique-containing-tag.rs b/src/test/run-pass/unique-containing-tag.rs
index 1ebd584aa5f..762a74b2455 100644
--- a/src/test/run-pass/unique-containing-tag.rs
+++ b/src/test/run-pass/unique-containing-tag.rs
@@ -11,7 +11,7 @@
 pub fn main() {
     enum t { t1(int), t2(int), }
 
-    let _x = ~t1(10);
+    let _x = box t1(10);
 
     /*alt *x {
       t1(a) {
@@ -21,7 +21,7 @@ pub fn main() {
     }*/
 
     /*alt x {
-      ~t1(a) {
+      box t1(a) {
         assert_eq!(a, 10);
       }
       _ { fail!(); }
diff --git a/src/test/run-pass/unique-create.rs b/src/test/run-pass/unique-create.rs
index 023917ec2e9..834b549d4f4 100644
--- a/src/test/run-pass/unique-create.rs
+++ b/src/test/run-pass/unique-create.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 pub fn main() {
-    ~100;
+    box 100;
 }
 
 fn vec() {
diff --git a/src/test/run-pass/unique-decl-init-copy.rs b/src/test/run-pass/unique-decl-init-copy.rs
index 13594d86f67..a5cb19ebad7 100644
--- a/src/test/run-pass/unique-decl-init-copy.rs
+++ b/src/test/run-pass/unique-decl-init-copy.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 pub fn main() {
-    let mut i = ~1;
+    let mut i = box 1;
     // Should be a copy
     let mut j = i.clone();
     *i = 2;
diff --git a/src/test/run-pass/unique-decl-init.rs b/src/test/run-pass/unique-decl-init.rs
index c507d19fac1..9cf28415481 100644
--- a/src/test/run-pass/unique-decl-init.rs
+++ b/src/test/run-pass/unique-decl-init.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 pub fn main() {
-    let i = ~1;
+    let i = box 1;
     let j = i;
     assert_eq!(*j, 1);
 }
diff --git a/src/test/run-pass/unique-decl-move-temp.rs b/src/test/run-pass/unique-decl-move-temp.rs
index 6cf781d735c..346b7d0bfcc 100644
--- a/src/test/run-pass/unique-decl-move-temp.rs
+++ b/src/test/run-pass/unique-decl-move-temp.rs
@@ -9,6 +9,6 @@
 // except according to those terms.
 
 pub fn main() {
-    let i = ~100;
+    let i = box 100;
     assert_eq!(*i, 100);
 }
diff --git a/src/test/run-pass/unique-decl-move.rs b/src/test/run-pass/unique-decl-move.rs
index 335275ff7c1..d2e8f991d21 100644
--- a/src/test/run-pass/unique-decl-move.rs
+++ b/src/test/run-pass/unique-decl-move.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 pub fn main() {
-    let i = ~100;
+    let i = box 100;
     let j = i;
     assert_eq!(*j, 100);
 }
diff --git a/src/test/run-pass/unique-decl.rs b/src/test/run-pass/unique-decl.rs
index 74b73d77369..7f894a8c324 100644
--- a/src/test/run-pass/unique-decl.rs
+++ b/src/test/run-pass/unique-decl.rs
@@ -8,10 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 pub fn main() {
-    let _: ~int;
+    let _: Box<int>;
 }
 
-fn f(_i: ~int) -> ~int {
+fn f(_i: Box<int>) -> Box<int> {
     fail!();
 }
diff --git a/src/test/run-pass/unique-deref.rs b/src/test/run-pass/unique-deref.rs
index 6cf781d735c..346b7d0bfcc 100644
--- a/src/test/run-pass/unique-deref.rs
+++ b/src/test/run-pass/unique-deref.rs
@@ -9,6 +9,6 @@
 // except according to those terms.
 
 pub fn main() {
-    let i = ~100;
+    let i = box 100;
     assert_eq!(*i, 100);
 }
diff --git a/src/test/run-pass/unique-destructure.rs b/src/test/run-pass/unique-destructure.rs
index 6c35cb4dba7..0b3041f2249 100644
--- a/src/test/run-pass/unique-destructure.rs
+++ b/src/test/run-pass/unique-destructure.rs
@@ -11,6 +11,6 @@
 struct Foo { a: int, b: int }
 
 pub fn main() {
-    let ~Foo{a, b} = ~Foo{a: 100, b: 200};
+    let box Foo{a, b} = box Foo{a: 100, b: 200};
     assert_eq!(a + b, 300);
 }
diff --git a/src/test/run-pass/unique-drop-complex.rs b/src/test/run-pass/unique-drop-complex.rs
index eb8fa640a0f..01aac804bb6 100644
--- a/src/test/run-pass/unique-drop-complex.rs
+++ b/src/test/run-pass/unique-drop-complex.rs
@@ -9,5 +9,5 @@
 // except according to those terms.
 
 pub fn main() {
-    let _x = ~vec!(0,0,0,0,0);
+    let _x = box vec!(0,0,0,0,0);
 }
diff --git a/src/test/run-pass/unique-fn-arg-move.rs b/src/test/run-pass/unique-fn-arg-move.rs
index 503bbae8c55..762c2c7ea0c 100644
--- a/src/test/run-pass/unique-fn-arg-move.rs
+++ b/src/test/run-pass/unique-fn-arg-move.rs
@@ -8,11 +8,12 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn f(i: ~int) {
+
+fn f(i: Box<int>) {
     assert_eq!(*i, 100);
 }
 
 pub fn main() {
-    let i = ~100;
+    let i = box 100;
     f(i);
 }
diff --git a/src/test/run-pass/unique-fn-arg-mut.rs b/src/test/run-pass/unique-fn-arg-mut.rs
index c2d78c33039..ccf6a4fd7ae 100644
--- a/src/test/run-pass/unique-fn-arg-mut.rs
+++ b/src/test/run-pass/unique-fn-arg-mut.rs
@@ -8,12 +8,13 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn f(i: &mut ~int) {
-    *i = ~200;
+
+fn f(i: &mut Box<int>) {
+    *i = box 200;
 }
 
 pub fn main() {
-    let mut i = ~100;
+    let mut i = box 100;
     f(&mut i);
     assert_eq!(*i, 200);
 }
diff --git a/src/test/run-pass/unique-fn-arg.rs b/src/test/run-pass/unique-fn-arg.rs
index 230131bae62..6769011cffe 100644
--- a/src/test/run-pass/unique-fn-arg.rs
+++ b/src/test/run-pass/unique-fn-arg.rs
@@ -8,12 +8,13 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn f(i: ~int) {
+
+fn f(i: Box<int>) {
     assert_eq!(*i, 100);
 }
 
 pub fn main() {
-    f(~100);
-    let i = ~100;
+    f(box 100);
+    let i = box 100;
     f(i);
 }
diff --git a/src/test/run-pass/unique-fn-ret.rs b/src/test/run-pass/unique-fn-ret.rs
index dd39e136fc9..8493652cf8a 100644
--- a/src/test/run-pass/unique-fn-ret.rs
+++ b/src/test/run-pass/unique-fn-ret.rs
@@ -8,10 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn f() -> ~int {
-    ~100
+
+fn f() -> Box<int> {
+    box 100
 }
 
 pub fn main() {
-    assert_eq!(f(), ~100);
+    assert_eq!(f(), box 100);
 }
diff --git a/src/test/run-pass/unique-generic-assign.rs b/src/test/run-pass/unique-generic-assign.rs
index 3805cbe47bf..58470637a11 100644
--- a/src/test/run-pass/unique-generic-assign.rs
+++ b/src/test/run-pass/unique-generic-assign.rs
@@ -10,7 +10,8 @@
 
 // Issue #976
 
-fn f<T>(x: ~T) {
+
+fn f<T>(x: Box<T>) {
     let _x2 = x;
 }
 pub fn main() { }
diff --git a/src/test/run-pass/unique-in-tag.rs b/src/test/run-pass/unique-in-tag.rs
index c5d55ff0386..2045beb7f32 100644
--- a/src/test/run-pass/unique-in-tag.rs
+++ b/src/test/run-pass/unique-in-tag.rs
@@ -8,10 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn test1() {
-    enum bar { u(~int), w(int), }
 
-    let x = u(~10);
+fn test1() {
+    enum bar { u(Box<int>), w(int), }
+
+    let x = u(box 10);
     assert!(match x {
       u(a) => {
         println!("{:?}", a);
diff --git a/src/test/run-pass/unique-in-vec-copy.rs b/src/test/run-pass/unique-in-vec-copy.rs
index c14af83ad87..f1f6a29dd22 100644
--- a/src/test/run-pass/unique-in-vec-copy.rs
+++ b/src/test/run-pass/unique-in-vec-copy.rs
@@ -10,7 +10,7 @@
 
 
 pub fn main() {
-    let mut a = vec!(~10);
+    let mut a = vec!(box 10);
     let b = a.clone();
 
     assert_eq!(**a.get(0), 10);
diff --git a/src/test/run-pass/unique-in-vec.rs b/src/test/run-pass/unique-in-vec.rs
index 82d3a29d901..9b2b66231e5 100644
--- a/src/test/run-pass/unique-in-vec.rs
+++ b/src/test/run-pass/unique-in-vec.rs
@@ -9,6 +9,6 @@
 // except according to those terms.
 
 pub fn main() {
-    let vect = vec!(~100);
-    assert!(*vect.get(0) == ~100);
+    let vect = vec!(box 100);
+    assert!(*vect.get(0) == box 100);
 }
diff --git a/src/test/run-pass/unique-init.rs b/src/test/run-pass/unique-init.rs
index 6a87dd30f7a..d7105b472cc 100644
--- a/src/test/run-pass/unique-init.rs
+++ b/src/test/run-pass/unique-init.rs
@@ -9,5 +9,5 @@
 // except according to those terms.
 
 pub fn main() {
-    let _i = ~100;
+    let _i = box 100;
 }
diff --git a/src/test/run-pass/unique-kinds.rs b/src/test/run-pass/unique-kinds.rs
index 118d0cd744d..6d088a1f6d4 100644
--- a/src/test/run-pass/unique-kinds.rs
+++ b/src/test/run-pass/unique-kinds.rs
@@ -20,11 +20,11 @@ fn sendable() {
         assert!(i != j);
     }
 
-    let i = ~100;
-    let j = ~100;
+    let i = box 100;
+    let j = box 100;
     f(i, j);
-    let i = ~100;
-    let j = ~101;
+    let i = box 100;
+    let j = box 101;
     g(i, j);
 }
 
@@ -38,11 +38,11 @@ fn copyable() {
         assert!(i != j);
     }
 
-    let i = ~100;
-    let j = ~100;
+    let i = box 100;
+    let j = box 100;
     f(i, j);
-    let i = ~100;
-    let j = ~101;
+    let i = box 100;
+    let j = box 101;
     g(i, j);
 }
 
@@ -56,11 +56,11 @@ fn noncopyable() {
         assert!(i != j);
     }
 
-    let i = ~100;
-    let j = ~100;
+    let i = box 100;
+    let j = box 100;
     f(i, j);
-    let i = ~100;
-    let j = ~101;
+    let i = box 100;
+    let j = box 101;
     g(i, j);
 }
 
diff --git a/src/test/run-pass/unique-log.rs b/src/test/run-pass/unique-log.rs
index 06f73777032..e2de566090d 100644
--- a/src/test/run-pass/unique-log.rs
+++ b/src/test/run-pass/unique-log.rs
@@ -9,6 +9,6 @@
 // except according to those terms.
 
 pub fn main() {
-    let i = ~100;
+    let i = box 100;
     println!("{:?}", i);
 }
diff --git a/src/test/run-pass/unique-match-discrim.rs b/src/test/run-pass/unique-match-discrim.rs
index 1f0b13dfd01..68b46db3a94 100644
--- a/src/test/run-pass/unique-match-discrim.rs
+++ b/src/test/run-pass/unique-match-discrim.rs
@@ -11,7 +11,7 @@
 // Issue #961
 
 fn altsimple() {
-    match ~true {
+    match box true {
       _ => { }
     }
 }
diff --git a/src/test/run-pass/unique-move-drop.rs b/src/test/run-pass/unique-move-drop.rs
index c757011f935..7ec0ce62329 100644
--- a/src/test/run-pass/unique-move-drop.rs
+++ b/src/test/run-pass/unique-move-drop.rs
@@ -11,8 +11,8 @@
 #![allow(unused_variable)]
 
 pub fn main() {
-    let i = ~100;
-    let j = ~200;
+    let i = box 100;
+    let j = box 200;
     let j = i;
     assert_eq!(*j, 100);
 }
diff --git a/src/test/run-pass/unique-move-temp.rs b/src/test/run-pass/unique-move-temp.rs
index 7c7ca1379ea..18cbbfa08df 100644
--- a/src/test/run-pass/unique-move-temp.rs
+++ b/src/test/run-pass/unique-move-temp.rs
@@ -10,6 +10,6 @@
 
 pub fn main() {
     let mut i;
-    i = ~100;
+    i = box 100;
     assert_eq!(*i, 100);
 }
diff --git a/src/test/run-pass/unique-move.rs b/src/test/run-pass/unique-move.rs
index dbdfc5cb5bb..14f6077be7a 100644
--- a/src/test/run-pass/unique-move.rs
+++ b/src/test/run-pass/unique-move.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 pub fn main() {
-    let i = ~100;
+    let i = box 100;
     let mut j;
     j = i;
     assert_eq!(*j, 100);
diff --git a/src/test/run-pass/unique-mutable.rs b/src/test/run-pass/unique-mutable.rs
index 4f353c56671..01a3ba6a3b4 100644
--- a/src/test/run-pass/unique-mutable.rs
+++ b/src/test/run-pass/unique-mutable.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 pub fn main() {
-    let mut i = ~0;
+    let mut i = box 0;
     *i = 1;
     assert_eq!(*i, 1);
 }
diff --git a/src/test/run-pass/unique-object-move.rs b/src/test/run-pass/unique-object-move.rs
index f6a46741366..6d0432faf55 100644
--- a/src/test/run-pass/unique-object-move.rs
+++ b/src/test/run-pass/unique-object-move.rs
@@ -10,6 +10,7 @@
 
 // Issue #5192
 
+
 pub trait EventLoop { }
 
 pub struct UvEventLoop {
@@ -19,6 +20,6 @@ pub struct UvEventLoop {
 impl EventLoop for UvEventLoop { }
 
 pub fn main() {
-    let loop_: ~EventLoop = ~UvEventLoop { uvio: 0 } as ~EventLoop;
+    let loop_: Box<EventLoop> = box UvEventLoop { uvio: 0 } as Box<EventLoop>;
     let _loop2_ = loop_;
 }
diff --git a/src/test/run-pass/unique-pat-2.rs b/src/test/run-pass/unique-pat-2.rs
index 49a873e793a..3f7138006e5 100644
--- a/src/test/run-pass/unique-pat-2.rs
+++ b/src/test/run-pass/unique-pat-2.rs
@@ -11,11 +11,11 @@
 
 struct Foo {a: int, b: uint}
 
-enum bar { u(~Foo), w(int), }
+enum bar { u(Box<Foo>), w(int), }
 
 pub fn main() {
-    assert!(match u(~Foo{a: 10, b: 40u}) {
-              u(~Foo{a: a, b: b}) => { a + (b as int) }
+    assert!(match u(box Foo{a: 10, b: 40u}) {
+              u(box Foo{a: a, b: b}) => { a + (b as int) }
               _ => { 66 }
             } == 50);
 }
diff --git a/src/test/run-pass/unique-pat-3.rs b/src/test/run-pass/unique-pat-3.rs
index 7f11e7b7df5..55fda4c1106 100644
--- a/src/test/run-pass/unique-pat-3.rs
+++ b/src/test/run-pass/unique-pat-3.rs
@@ -9,10 +9,10 @@
 // except according to those terms.
 
 
-enum bar { u(~int), w(int), }
+enum bar { u(Box<int>), w(int), }
 
 pub fn main() {
-    assert!(match u(~10) {
+    assert!(match u(box 10) {
       u(a) => {
         println!("{:?}", a);
         *a
diff --git a/src/test/run-pass/unique-pat.rs b/src/test/run-pass/unique-pat.rs
index 0b9ad6ee194..297ded0222d 100644
--- a/src/test/run-pass/unique-pat.rs
+++ b/src/test/run-pass/unique-pat.rs
@@ -9,8 +9,8 @@
 // except according to those terms.
 
 fn simple() {
-    match ~true {
-      ~true => { }
+    match box true {
+      box true => { }
       _ => { fail!(); }
     }
 }
diff --git a/src/test/run-pass/unique-rec.rs b/src/test/run-pass/unique-rec.rs
index f740dd2a22c..ff7f009990d 100644
--- a/src/test/run-pass/unique-rec.rs
+++ b/src/test/run-pass/unique-rec.rs
@@ -11,7 +11,7 @@
 struct X { x: int }
 
 pub fn main() {
-    let x = ~X {x: 1};
+    let x = box X {x: 1};
     let bar = x;
     assert_eq!(bar.x, 1);
 }
diff --git a/src/test/run-pass/unique-send-2.rs b/src/test/run-pass/unique-send-2.rs
index eec68dae108..432a0527ada 100644
--- a/src/test/run-pass/unique-send-2.rs
+++ b/src/test/run-pass/unique-send-2.rs
@@ -10,8 +10,8 @@
 
 use std::task;
 
-fn child(tx: &Sender<~uint>, i: uint) {
-    tx.send(~i);
+fn child(tx: &Sender<Box<uint>>, i: uint) {
+    tx.send(box i);
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/unique-send.rs b/src/test/run-pass/unique-send.rs
index aced7a33da7..5d622f5cfe8 100644
--- a/src/test/run-pass/unique-send.rs
+++ b/src/test/run-pass/unique-send.rs
@@ -10,7 +10,7 @@
 
 pub fn main() {
     let (tx, rx) = channel();
-    tx.send(~100);
+    tx.send(box 100);
     let v = rx.recv();
-    assert_eq!(v, ~100);
+    assert_eq!(v, box 100);
 }
diff --git a/src/test/run-pass/unique-swap.rs b/src/test/run-pass/unique-swap.rs
index 779606dba0c..1299b28a67e 100644
--- a/src/test/run-pass/unique-swap.rs
+++ b/src/test/run-pass/unique-swap.rs
@@ -11,9 +11,9 @@
 use std::mem::swap;
 
 pub fn main() {
-    let mut i = ~100;
-    let mut j = ~200;
+    let mut i = box 100;
+    let mut j = box 200;
     swap(&mut i, &mut j);
-    assert_eq!(i, ~200);
-    assert_eq!(j, ~100);
+    assert_eq!(i, box 200);
+    assert_eq!(j, box 100);
 }
diff --git a/src/test/run-pass/unsized2.rs b/src/test/run-pass/unsized2.rs
index 7883adad46a..53db7f37e8d 100644
--- a/src/test/run-pass/unsized2.rs
+++ b/src/test/run-pass/unsized2.rs
@@ -9,6 +9,7 @@
 // except according to those terms.
 #![feature(struct_variant)]
 
+
 // Test sized-ness checking in substitution.
 
 // Unbounded.
@@ -32,33 +33,33 @@ fn f4<X: T>(x: &X) {
 
 // Self type.
 trait T2 for type {
-    fn f() -> ~Self;
+    fn f() -> Box<Self>;
 }
 struct S;
 impl T2 for S {
-    fn f() -> ~S {
-        ~S
+    fn f() -> Box<S> {
+        box S
     }
 }
 fn f5<type X: T2>(x: &X) {
-    let _: ~X = T2::f();
+    let _: Box<X> = T2::f();
 }
 fn f6<X: T2>(x: &X) {
-    let _: ~X = T2::f();
+    let _: Box<X> = T2::f();
 }
 
 trait T3 for type {
-    fn f() -> ~Self;
+    fn f() -> Box<Self>;
 }
 impl T3 for S {
-    fn f() -> ~S {
-        ~S
+    fn f() -> Box<S> {
+        box S
     }
 }
 fn f7<type X: T3>(x: &X) {
     // This is valid, but the unsized bound on X is irrelevant because any type
     // which implements T3 must have statically known size.
-    let _: ~X = T3::f();
+    let _: Box<X> = T3::f();
 }
 
 trait T4<X> {
diff --git a/src/test/run-pass/unused-move-capture.rs b/src/test/run-pass/unused-move-capture.rs
index ceb91d557f6..83795e64467 100644
--- a/src/test/run-pass/unused-move-capture.rs
+++ b/src/test/run-pass/unused-move-capture.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 pub fn main() {
-    let _x = ~1;
+    let _x = box 1;
     let lam_move: || = || {};
     lam_move();
 }
diff --git a/src/test/run-pass/unused-move.rs b/src/test/run-pass/unused-move.rs
index 163726fd06a..bac9ce814bc 100644
--- a/src/test/run-pass/unused-move.rs
+++ b/src/test/run-pass/unused-move.rs
@@ -16,6 +16,6 @@
 
 pub fn main()
 {
-    let y = ~1;
+    let y = box 1;
     y;
 }
diff --git a/src/test/run-pass/unwind-unique.rs b/src/test/run-pass/unwind-unique.rs
index 8bc95b233f1..ce252439618 100644
--- a/src/test/run-pass/unwind-unique.rs
+++ b/src/test/run-pass/unwind-unique.rs
@@ -11,7 +11,7 @@
 use std::task;
 
 fn f() {
-    let _a = ~0;
+    let _a = box 0;
     fail!();
 }