diff --git a/.gitignore b/.gitignore
index f264288..6816cb1 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,8 @@
 http_client
 *~
 *.so
-*.dylib
\ No newline at end of file
+*.dylib
+*.a
+*.dummy
+*.o
+Makefile
diff --git a/http_client.rc b/http_client.rc
index 69a5e07..e6ac26a 100644
--- a/http_client.rc
+++ b/http_client.rc
@@ -20,7 +20,7 @@ use std::net::ip::{
     IpAddr, IpGetAddrErr, Ipv4, Ipv6
 };
 use std::net::tcp::{connect, TcpErrData, TcpSocket};
-use std::net::url::Url;
+use std::net::url;
 use std::uv_global_loop;
 use connection::{
     Connection, ConnectionFactory, UvConnectionFactory,
@@ -53,7 +53,7 @@ pub enum RequestError {
     ErrorMisc
 }
 
-/// Request 
+/// Request
 #[deriving(Eq)]
 pub enum RequestEvent {
     Status(StatusCode),
@@ -71,7 +71,7 @@ pub fn uv_dns_resolver() -> DnsResolver {
     return r;
 }
 
-pub fn uv_http_request(url: Url) -> HttpRequest<TcpSocket, UvConnectionFactory> {
+pub fn uv_http_request(url: url::Url) -> HttpRequest<TcpSocket, UvConnectionFactory> {
     HttpRequest(uv_dns_resolver(), UvConnectionFactory, url)
 }
 
@@ -79,14 +79,14 @@ pub fn uv_http_request(url: Url) -> HttpRequest<TcpSocket, UvConnectionFactory>
 pub struct HttpRequest<C, CF> {
     resolve_ip_addr: DnsResolver,
     connection_factory: CF,
-    url: Url,
+    url: url::Url,
     parser: Parser,
     cb: @fn(+ev: RequestEvent)
 }
 
 pub fn HttpRequest<C: Connection, CF: ConnectionFactory<C>>(resolver: DnsResolver,
                                                             connection_factory: CF,
-                                                            url: Url) ->
+                                                            url: url::Url) ->
                                                             HttpRequest<C,CF> {
     HttpRequest {
         resolve_ip_addr: resolver,
@@ -265,9 +265,9 @@ pub impl<C: Connection, CF: ConnectionFactory<C>> HttpRequest<C, CF> {
 }
 
 #[allow(non_implicitly_copyable_typarams)]
-pub fn sequence<C: Connection, CF: ConnectionFactory<C>>(request: &mut HttpRequest<C, CF>) -> 
+pub fn sequence<C: Connection, CF: ConnectionFactory<C>>(request: &mut HttpRequest<C, CF>) ->
     ~[RequestEvent] {
-    
+
     let events = @mut ~[];
     do request.begin |event| {
         vec::push(&mut *events, event)
@@ -279,10 +279,10 @@ pub fn sequence<C: Connection, CF: ConnectionFactory<C>>(request: &mut HttpReque
 #[allow(non_implicitly_copyable_typarams)]
 pub fn test_resolve_error() {
     let url = url::from_str(~"http://example.com_not_real/").get();
-    let request = uv_http_request(url);
-    let events = sequence(request);
+    let mut request = uv_http_request(url);
+    let events = sequence(&mut request);
 
-    fail_unless!(events == ~[
+    assert!(events == ~[
         Error(ErrorDnsResolution),
     ]);
 }
@@ -293,10 +293,10 @@ pub fn test_connect_error() {
     // This address is invalid because the first octet
     // of a class A address cannot be 0
     let url = url::from_str(~"http://0.42.42.42/").get();
-    let request = uv_http_request(url);
-    let events = sequence(request);
+    let mut request = uv_http_request(url);
+    let events = sequence(&mut request);
 
-    fail_unless!(events == ~[
+    assert!(events == ~[
         Error(ErrorConnect),
     ]);
 }
@@ -305,8 +305,8 @@ pub fn test_connect_error() {
 #[allow(non_implicitly_copyable_typarams)]
 pub fn test_connect_success() {
     let url = url::from_str(~"http://example.com/").get();
-    let request = uv_http_request(url);
-    let events = sequence(request);
+    let mut request = uv_http_request(url);
+    let events = sequence(&mut request);
 
     for events.each |ev| {
         match *ev {
@@ -321,15 +321,15 @@ pub fn test_connect_success() {
 #[allow(non_implicitly_copyable_typarams)]
 pub fn test_simple_body() {
     let url = url::from_str(~"http://www.iana.org/").get();
-    let request = uv_http_request(url);
-    let events = sequence(request);
+    let mut request = uv_http_request(url);
+    let events = sequence(&mut request);
 
     let mut found = false;
 
     for events.each |ev| {
         match ev {
           &Payload(ref value) => {
-            if str::from_bytes((copy value).get()).to_lower().contains(~"doctype html") {
+            if str::from_bytes((copy value).take()).to_lower().contains(~"doctype html") {
                 found = true
             }
           }
@@ -337,7 +337,7 @@ pub fn test_simple_body() {
         }
     }
 
-    fail_unless!(found);
+    assert!(found);
 }
 
 #[test]
diff --git a/http_parser.rs b/http_parser.rs
index 1115773..9242b48 100644
--- a/http_parser.rs
+++ b/http_parser.rs
@@ -457,8 +457,8 @@ struct struct_unnamed1 {
     len: uint16_t,
 }
 
-#[nolink]
-#[link_args = "-L. -lhttp_parser"]
+#[link_name = "http_parser"]
+#[link_args = "-L."]
 pub extern mod bindgen {
 
 fn http_parser_init(++parser: *http_parser, ++_type: enum_http_parser_type);
diff --git a/parser.rs b/parser.rs
index 2470969..d3fe02e 100644
--- a/parser.rs
+++ b/parser.rs
@@ -81,7 +81,7 @@ pub impl Parser {
 
 fn callbacks(http_parser: *http_parser::http_parser) -> *ParserCallbacks {
     unsafe {
-        fail_unless!((*http_parser).data.is_not_null());
+        assert!((*http_parser).data.is_not_null());
         return (*http_parser).data as *ParserCallbacks;
     }
 }
diff --git a/pkg.rs b/pkg.rs
new file mode 100644
index 0000000..4c1fc00
--- /dev/null
+++ b/pkg.rs
@@ -0,0 +1,13 @@
+#[pkg(id = "http_client",
+      vers = "0.1.0")];
+
+extern mod rustpkg;
+use core::run;
+
+#[pkg_do(build)]
+fn main() {
+    run::run_program("./configure", []);
+    run::run_program("make", []);
+    let crate = rustpkg::Crate(~"http_client.rc");
+    rustpkg::build(~[crate]);
+}
diff --git a/request.rs b/request.rs
index 2ee6ab0..d2ba82f 100644
--- a/request.rs
+++ b/request.rs
@@ -1,6 +1,6 @@
-use std::net::url::Url;
+use std::net::url;
 
-pub fn build_request(url: Url) -> ~str {
+pub fn build_request(url: url::Url) -> ~str {
 
     let host = copy url.host;
     let mut path = if url.path.len() > 0 { copy url.path } else { ~"/" };
@@ -24,7 +24,7 @@ pub fn build_request(url: Url) -> ~str {
 #[allow(non_implicitly_copyable_typarams)]
 fn should_request_slash_when_path_is_empty() {
     let url = url::from_str(~"http://host").get();
-    fail_unless!(url.path.is_empty());
+    assert!(url.path.is_empty());
     let headers = build_request(url);
-    fail_unless!(headers.contains(~"GET / "));
+    assert!(headers.contains(~"GET / "));
 }