diff --git a/src/libstd/rt/bookkeeping.rs b/src/libstd/rt/bookkeeping.rs
deleted file mode 100644
index aca520fc088f5..0000000000000
--- a/src/libstd/rt/bookkeeping.rs
+++ /dev/null
@@ -1,61 +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.
-
-//! Task bookkeeping
-//!
-//! This module keeps track of the number of running tasks so that entry points
-//! with libnative know when it's possible to exit the program (once all tasks
-//! have exited).
-//!
-//! The green counterpart for this is bookkeeping on sched pools, and it's up to
-//! each respective runtime to make sure that they call increment() and
-//! decrement() manually.
-
-use sync::atomic;
-use ops::Drop;
-
-use rt::mutex::{StaticNativeMutex, NATIVE_MUTEX_INIT};
-
-static TASK_COUNT: atomic::AtomicUint = atomic::INIT_ATOMIC_UINT;
-static TASK_LOCK: StaticNativeMutex = NATIVE_MUTEX_INIT;
-
-#[allow(missing_copy_implementations)]
-pub struct Token { _private: () }
-
-impl Drop for Token {
-    fn drop(&mut self) { decrement() }
-}
-
-/// Increment the number of live tasks, returning a token which will decrement
-/// the count when dropped.
-pub fn increment() -> Token {
-    let _ = TASK_COUNT.fetch_add(1, atomic::SeqCst);
-    Token { _private: () }
-}
-
-pub fn decrement() {
-    unsafe {
-        if TASK_COUNT.fetch_sub(1, atomic::SeqCst) == 1 {
-            let guard = TASK_LOCK.lock();
-            guard.signal();
-        }
-    }
-}
-
-/// Waits for all other native tasks in the system to exit. This is only used by
-/// the entry points of native programs
-pub fn wait_for_other_tasks() {
-    unsafe {
-        let guard = TASK_LOCK.lock();
-        while TASK_COUNT.load(atomic::SeqCst) > 0 {
-            guard.wait();
-        }
-    }
-}
diff --git a/src/libstd/rt/mod.rs b/src/libstd/rt/mod.rs
index 5d5ccefda5dc2..676dbb0b498a6 100644
--- a/src/libstd/rt/mod.rs
+++ b/src/libstd/rt/mod.rs
@@ -73,7 +73,6 @@ pub mod mutex;
 pub mod thread;
 pub mod exclusive;
 pub mod util;
-pub mod bookkeeping;
 pub mod local;
 pub mod task;
 pub mod unwind;
@@ -207,7 +206,6 @@ pub fn at_exit(f: proc():Send) {
 /// Invoking cleanup while portions of the runtime are still in use may cause
 /// undefined behavior.
 pub unsafe fn cleanup() {
-    bookkeeping::wait_for_other_tasks();
     args::cleanup();
     thread::cleanup();
     local_ptr::cleanup();
diff --git a/src/libstd/rt/task.rs b/src/libstd/rt/task.rs
index babd111b3c221..98940a2b381c7 100644
--- a/src/libstd/rt/task.rs
+++ b/src/libstd/rt/task.rs
@@ -29,7 +29,6 @@ use str::SendStr;
 use thunk::Thunk;
 
 use rt;
-use rt::bookkeeping;
 use rt::mutex::NativeMutex;
 use rt::local::Local;
 use rt::thread::{mod, Thread};
@@ -132,11 +131,6 @@ impl Task {
 
         let stack = stack_size.unwrap_or(rt::min_stack());
 
-        // Note that this increment must happen *before* the spawn in order to
-        // guarantee that if this task exits it will always end up waiting for
-        // the spawned task to exit.
-        let token = bookkeeping::increment();
-
         // Spawning a new OS thread guarantees that __morestack will never get
         // triggered, but we must manually set up the actual stack bounds once
         // this function starts executing. This raises the lower limit by a bit
@@ -156,7 +150,6 @@ impl Task {
 
             let mut f = Some(f);
             drop(task.run(|| { f.take().unwrap().invoke(()) }).destroy());
-            drop(token);
         })
     }
 
diff --git a/src/libstd/sys/common/helper_thread.rs b/src/libstd/sys/common/helper_thread.rs
index ffb053e852efc..ef0181b72b0b7 100644
--- a/src/libstd/sys/common/helper_thread.rs
+++ b/src/libstd/sys/common/helper_thread.rs
@@ -25,7 +25,7 @@ use prelude::*;
 use cell::UnsafeCell;
 use mem;
 use sync::{StaticMutex, StaticCondvar};
-use rt::{mod, bookkeeping};
+use rt;
 use sys::helper_signal;
 
 use task;
@@ -83,7 +83,6 @@ impl<M: Send> Helper<M> {
 
                 let t = f();
                 task::spawn(move |:| {
-                    bookkeeping::decrement();
                     helper(receive, rx, t);
                     let _g = self.lock.lock();
                     *self.shutdown.get() = true;