diff --git a/.travis.yml b/.travis.yml
index 0bcbb0c..d3547db 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -13,7 +13,7 @@
   - linux
   - osx
 
-cache: rust
+cache: cargo
 
 install:
   - rustup target add thumbv7em-none-eabi
@@ -22,7 +22,4 @@
   - rustup component add clippy
 
 script:
-  - cargo fmt --all -- --check
-  - cargo test --workspace
-  - cargo clippy --workspace --all-targets
-  - ./build_examples.sh
+  - ./run_all_checks.sh
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 17c8d81..d15206f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -17,7 +17,8 @@
   - `syscalls::allow_ptr` becomes `syscalls::raw::allow`
 - Targets without support for atomics can be built
 - Most API functions, including `main()`, return a `Result<T, TockError>`
-- The timer now supports to be used simultaneously. To make this safe, `TimerDriver` is now a singleton.
+- The library now supports parallel timers
+- all drivers can exclusively be retrieved by `retrieve_drivers` which returns a `Drivers`-singleton. Drivers can be shared between different tasks only if it is safe to do so.
 
 ## a8bb4fa9be504517d5533511fd8e607ea61f1750 (0.1.0)
 
diff --git a/examples/adc.rs b/examples/adc.rs
index 61894ad..ef100a3 100644
--- a/examples/adc.rs
+++ b/examples/adc.rs
@@ -1,20 +1,23 @@
 #![no_std]
 
 use core::fmt::Write;
-use libtock::adc;
-use libtock::console::Console;
 use libtock::result::TockResult;
-use libtock::timer;
 use libtock::timer::Duration;
+use libtock::Drivers;
 
 #[libtock::main]
 async fn main() -> TockResult<()> {
-    let context = timer::DriverContext::create()?;
-    let mut driver = context.create_timer_driver()?;
-    let timer_driver = driver.activate()?;
+    let Drivers {
+        console_driver,
+        timer_context,
+        adc_driver,
+        ..
+    } = libtock::retrieve_drivers()?;
 
-    let mut console = Console::default();
-    let mut with_callback = adc::with_callback(|channel: usize, value: usize| {
+    let mut driver = timer_context.create_timer_driver();
+    let timer_driver = driver.activate()?;
+    let mut console = console_driver.create_console();
+    let mut with_callback = adc_driver.with_callback(|channel: usize, value: usize| {
         writeln!(console, "channel: {}, value: {}", channel, value).unwrap();
     });
 
diff --git a/examples/adc_buffer.rs b/examples/adc_buffer.rs
index 406bf57..b948b93 100644
--- a/examples/adc_buffer.rs
+++ b/examples/adc_buffer.rs
@@ -1,22 +1,26 @@
 #![no_std]
 
 use core::fmt::Write;
-use libtock::adc;
 use libtock::adc::AdcBuffer;
-use libtock::console::Console;
 use libtock::result::TockResult;
 use libtock::syscalls;
+use libtock::Drivers;
 
 #[libtock::main]
 /// Reads a 128 byte sample into a buffer and prints the first value to the console.
 async fn main() -> TockResult<()> {
-    let mut console = Console::default();
+    let Drivers {
+        console_driver,
+        adc_driver,
+        ..
+    } = libtock::retrieve_drivers()?;
+    let mut console = console_driver.create_console();
     let mut adc_buffer = AdcBuffer::default();
     let mut temp_buffer = [0; libtock::adc::BUFFER_SIZE];
 
     let adc_buffer = libtock::adc::Adc::init_buffer(&mut adc_buffer)?;
 
-    let mut with_callback = adc::with_callback(|_, _| {
+    let mut with_callback = adc_driver.with_callback(|_, _| {
         adc_buffer.read_bytes(&mut temp_buffer[..]);
         writeln!(console, "First sample in buffer: {}", temp_buffer[0]).unwrap();
     });
diff --git a/examples/ble_scanning.rs b/examples/ble_scanning.rs
index 78de325..a00ed46 100644
--- a/examples/ble_scanning.rs
+++ b/examples/ble_scanning.rs
@@ -2,11 +2,11 @@
 
 use futures::future;
 use libtock::ble_parser;
-use libtock::led;
 use libtock::result::TockResult;
 use libtock::simple_ble;
 use libtock::simple_ble::BleCallback;
-use libtock::simple_ble::BleDriver;
+use libtock::simple_ble::BleScanningDriver;
+use libtock::Drivers;
 use serde::Deserialize;
 
 #[derive(Deserialize)]
@@ -17,19 +17,31 @@
 
 #[libtock::main]
 async fn main() -> TockResult<()> {
-    let mut shared_buffer = BleDriver::create_scan_buffer();
-    let mut my_buffer = BleDriver::create_scan_buffer();
-    let shared_memory = BleDriver::share_memory(&mut shared_buffer)?;
+    let Drivers {
+        led_driver_factory,
+        mut ble_scanning_driver,
+        ..
+    } = libtock::retrieve_drivers()?;
+
+    let led_driver = led_driver_factory.create_driver()?;
+
+    let mut shared_buffer = BleScanningDriver::create_scan_buffer();
+    let mut my_buffer = BleScanningDriver::create_scan_buffer();
+    let shared_memory = ble_scanning_driver.share_memory(&mut shared_buffer)?;
 
     let mut callback = BleCallback::new(|_: usize, _: usize| {
         shared_memory.read_bytes(&mut my_buffer[..]);
         ble_parser::find(&my_buffer, simple_ble::gap_data::SERVICE_DATA as u8)
             .and_then(|service_data| ble_parser::extract_for_service([91, 79], service_data))
             .and_then(|payload| corepack::from_bytes::<LedCommand>(&payload).ok())
-            .and_then(|msg| led::get(msg.nr as usize).map(|led| led.set_state(msg.st)));
+            .and_then(|msg| {
+                led_driver
+                    .get(msg.nr as usize)
+                    .map(|led| led.set_state(msg.st))
+            });
     });
 
-    let _subscription = BleDriver::start(&mut callback)?;
+    let _subscription = ble_scanning_driver.start(&mut callback)?;
 
     future::pending().await
 }
diff --git a/examples/blink.rs b/examples/blink.rs
index f37fd12..aa9b64c 100644
--- a/examples/blink.rs
+++ b/examples/blink.rs
@@ -1,26 +1,31 @@
 #![no_std]
 
-use libtock::led;
 use libtock::result::TockResult;
-use libtock::timer;
 use libtock::timer::Duration;
+use libtock::Drivers;
 
 #[libtock::main]
 async fn main() -> TockResult<()> {
-    let num_leds = led::count()?;
-    let context = timer::DriverContext::create()?;
-    let mut driver = context.create_timer_driver()?;
+    let Drivers {
+        led_driver_factory,
+        timer_context,
+        ..
+    } = libtock::retrieve_drivers()?;
+
+    let mut driver = timer_context.create_timer_driver();
     let timer_driver = driver.activate()?;
+    let led_driver = led_driver_factory.create_driver()?;
 
     // Blink the LEDs in a binary count pattern and scale
     // to the number of LEDs on the board.
     let mut count: usize = 0;
     loop {
-        for i in 0..num_leds {
+        for led in led_driver.all() {
+            let i = led.number();
             if count & (1 << i) == (1 << i) {
-                led::get(i).unwrap().on()?;
+                led.on()?;
             } else {
-                led::get(i).unwrap().off()?;
+                led.off()?;
             }
         }
         count = count.wrapping_add(1);
diff --git a/examples/blink_random.rs b/examples/blink_random.rs
index 6b964a2..8734693 100644
--- a/examples/blink_random.rs
+++ b/examples/blink_random.rs
@@ -1,38 +1,45 @@
 #![no_std]
 
-use libtock::led;
+use libtock::led::LedDriver;
 use libtock::result::TockResult;
-use libtock::rng;
-use libtock::timer;
 use libtock::timer::Duration;
+use libtock::Drivers;
 
 #[libtock::main]
 async fn main() -> TockResult<()> {
-    let context = timer::DriverContext::create()?;
-    let mut driver = context.create_timer_driver()?;
+    let Drivers {
+        timer_context,
+        mut rng_driver,
+        led_driver_factory,
+        ..
+    } = libtock::retrieve_drivers()?;
+
+    let led_driver = led_driver_factory.create_driver()?;
+
+    let mut driver = timer_context.create_timer_driver();
     let timer_driver = driver.activate()?;
 
-    let num_leds = led::count()?;
+    let num_leds = led_driver.count()?;
     // blink_nibble assumes 4 leds.
     assert_eq!(num_leds, 4);
 
     let mut buf = [0; 64];
     loop {
-        rng::fill_buffer(&mut buf).await?;
+        rng_driver.fill_buffer(&mut buf).await?;
 
         for &x in buf.iter() {
-            blink_nibble(x)?;
+            blink_nibble(x, &led_driver)?;
             timer_driver.sleep(Duration::from_ms(100)).await?;
-            blink_nibble(x >> 4)?;
+            blink_nibble(x >> 4, &led_driver)?;
             timer_driver.sleep(Duration::from_ms(100)).await?;
         }
     }
 }
 
 // Takes the 4 least-significant bits of x, and turn the 4 leds on/off accordingly.
-fn blink_nibble(x: u8) -> TockResult<()> {
+fn blink_nibble(x: u8, led_driver: &LedDriver) -> TockResult<()> {
     for i in 0..4 {
-        let led = led::get(i).unwrap();
+        let led = led_driver.get(i).unwrap();
         if (x >> i) & 1 != 0 {
             led.on()?;
         } else {
diff --git a/examples/button_leds.rs b/examples/button_leds.rs
index 294d45a..ce6565f 100644
--- a/examples/button_leds.rs
+++ b/examples/button_leds.rs
@@ -1,16 +1,23 @@
 #![no_std]
 
 use futures::future;
-use libtock::buttons;
 use libtock::buttons::ButtonState;
-use libtock::led;
 use libtock::result::TockResult;
+use libtock::Drivers;
 
 #[libtock::main]
 async fn main() -> TockResult<()> {
-    let mut with_callback = buttons::with_callback(|button_num: usize, state| {
+    let Drivers {
+        led_driver_factory,
+        button_driver,
+        ..
+    } = libtock::retrieve_drivers()?;
+
+    let led_driver = led_driver_factory.create_driver()?;
+
+    let mut with_callback = button_driver.with_callback(|button_num: usize, state| {
         match state {
-            ButtonState::Pressed => led::get(button_num).unwrap().toggle().ok().unwrap(),
+            ButtonState::Pressed => led_driver.get(button_num).unwrap().toggle().ok().unwrap(),
             ButtonState::Released => (),
         };
     });
diff --git a/examples/button_read.rs b/examples/button_read.rs
index d86e70d..2ce209f 100644
--- a/examples/button_read.rs
+++ b/examples/button_read.rs
@@ -1,23 +1,26 @@
 #![no_std]
 
 use core::fmt::Write;
-use libtock::buttons;
 use libtock::buttons::ButtonState;
-use libtock::console::Console;
 use libtock::result::TockResult;
-use libtock::timer;
 use libtock::timer::Duration;
+use libtock::Drivers;
 
 #[libtock::main]
 async fn main() -> TockResult<()> {
-    let mut console = Console::default();
-    let mut with_callback = buttons::with_callback(|_, _| {});
+    let Drivers {
+        console_driver,
+        timer_context,
+        button_driver,
+        ..
+    } = libtock::retrieve_drivers()?;
+    let mut console = console_driver.create_console();
+    let mut with_callback = button_driver.with_callback(|_, _| {});
     let mut buttons = with_callback.init()?;
     let mut button = buttons.iter_mut().next().unwrap();
     let button = button.enable()?;
 
-    let context = timer::DriverContext::create()?;
-    let mut driver = context.create_timer_driver()?;
+    let mut driver = timer_context.create_timer_driver();
     let timer_driver = driver.activate()?;
 
     loop {
diff --git a/examples/button_subscribe.rs b/examples/button_subscribe.rs
index 3453c9b..268e6f0 100644
--- a/examples/button_subscribe.rs
+++ b/examples/button_subscribe.rs
@@ -2,17 +2,20 @@
 
 use core::fmt::Write;
 use futures::future;
-use libtock::buttons;
 use libtock::buttons::ButtonState;
-use libtock::console::Console;
 use libtock::result::TockResult;
+use libtock::Drivers;
 
 // FIXME: Hangs up when buttons are pressed rapidly. Yielding in callback leads to stack overflow.
 #[libtock::main]
 async fn main() -> TockResult<()> {
-    let mut console = Console::default();
-
-    let mut with_callback = buttons::with_callback(|button_num: usize, state| {
+    let Drivers {
+        console_driver,
+        button_driver,
+        ..
+    } = libtock::retrieve_drivers()?;
+    let mut console = console_driver.create_console();
+    let mut with_callback = button_driver.with_callback(|button_num: usize, state| {
         writeln!(
             console,
             "Button: {} - State: {}",
diff --git a/examples/gpio.rs b/examples/gpio.rs
index e472f2a..ee42d69 100644
--- a/examples/gpio.rs
+++ b/examples/gpio.rs
@@ -1,17 +1,20 @@
 #![no_std]
 
-use libtock::gpio::GpioPinUnitialized;
 use libtock::result::TockResult;
-use libtock::timer;
 use libtock::timer::Duration;
+use libtock::Drivers;
 
 // Example works on P0.03
 #[libtock::main]
 async fn main() -> TockResult<()> {
-    let pin = GpioPinUnitialized::new(0);
+    let Drivers {
+        timer_context,
+        gpio_driver,
+        ..
+    } = libtock::retrieve_drivers()?;
+    let pin = gpio_driver.pin(0)?;
     let pin = pin.open_for_write()?;
-    let context = timer::DriverContext::create()?;
-    let mut driver = context.create_timer_driver()?;
+    let mut driver = timer_context.create_timer_driver();
     let timer_driver = driver.activate()?;
 
     loop {
diff --git a/examples/gpio_read.rs b/examples/gpio_read.rs
index ad871ac..5e3d403 100644
--- a/examples/gpio_read.rs
+++ b/examples/gpio_read.rs
@@ -1,21 +1,24 @@
 #![no_std]
 
 use core::fmt::Write;
-use libtock::console::Console;
-use libtock::gpio::GpioPinUnitialized;
 use libtock::gpio::InputMode;
 use libtock::result::TockResult;
-use libtock::timer;
 use libtock::timer::Duration;
+use libtock::Drivers;
 
 // example works on p0.03
 #[libtock::main]
 async fn main() -> TockResult<()> {
-    let mut console = Console::default();
-    let pin = GpioPinUnitialized::new(0);
+    let Drivers {
+        console_driver,
+        timer_context,
+        gpio_driver,
+        ..
+    } = libtock::retrieve_drivers()?;
+    let mut console = console_driver.create_console();
+    let pin = gpio_driver.pin(0)?;
     let pin = pin.open_for_read(None, InputMode::PullDown)?;
-    let context = timer::DriverContext::create()?;
-    let mut driver = context.create_timer_driver()?;
+    let mut driver = timer_context.create_timer_driver();
     let timer_driver = driver.activate()?;
 
     loop {
diff --git a/examples/hardware_test.rs b/examples/hardware_test.rs
index 4f8ad5f..db2dd34 100644
--- a/examples/hardware_test.rs
+++ b/examples/hardware_test.rs
@@ -8,10 +8,13 @@
 use core::fmt::Write;
 use futures::future;
 use libtock::console::Console;
-use libtock::gpio::{GpioPinUnitialized, InputMode};
+use libtock::gpio::GpioPinRead;
+use libtock::gpio::GpioPinWrite;
+use libtock::gpio::InputMode;
 use libtock::result::TockResult;
-use libtock::timer;
+use libtock::timer::DriverContext;
 use libtock::timer::Duration;
+use libtock::Drivers;
 
 static mut STATIC: usize = 0;
 
@@ -33,18 +36,30 @@
 
 #[libtock::main]
 async fn main() -> TockResult<()> {
-    let mut console = Console::default();
+    let Drivers {
+        console_driver,
+        gpio_driver,
+        mut timer_context,
+        ..
+    } = libtock::retrieve_drivers()?;
+    let mut gpio_iter = gpio_driver.all_pins()?;
+    let mut console = console_driver.create_console();
+    let pin_in = gpio_iter.next().unwrap();
+    let pin_out = gpio_iter.next().unwrap();
+    let pin_in = pin_in.open_for_read(None, InputMode::PullDown)?;
+    let mut pin_out = pin_out.open_for_write()?;
+
     writeln!(console, "[test-results]")?;
 
     test_heap(&mut console);
     test_formatting(&mut console);
     test_static_mut(&mut console);
 
-    test_gpio(&mut console);
+    test_gpio(&mut console, &pin_in, &mut pin_out);
 
-    test_trait_objects(&mut console)?;
+    test_trait_objects(&mut console, &pin_in, &mut pin_out)?;
 
-    test_callbacks_and_wait_forever(&mut console).await
+    test_callbacks_and_wait_forever(&mut console, &mut timer_context).await
 }
 
 fn test_heap(console: &mut Console) {
@@ -61,12 +76,11 @@
 /// Output order should be:
 /// trait_obj_value_usize = 1
 /// trait_obj_value_string = string
-fn test_trait_objects(console: &mut Console) -> TockResult<()> {
-    let pin_in = GpioPinUnitialized::new(0);
-    let pin_in = pin_in.open_for_read(None, InputMode::PullDown)?;
-
-    let pin_out = GpioPinUnitialized::new(1);
-    let pin_out = pin_out.open_for_write()?;
+fn test_trait_objects(
+    console: &mut Console,
+    pin_in: &GpioPinRead,
+    pin_out: &mut GpioPinWrite,
+) -> TockResult<()> {
     pin_out.set_high()?;
 
     let string = String::from("string");
@@ -95,22 +109,17 @@
 }
 
 /// needs P0.03 and P0.04 to be connected
-fn test_gpio(console: &mut Console) {
-    let pin_in = GpioPinUnitialized::new(0);
-    let pin_in = pin_in
-        .open_for_read(None, InputMode::PullDown)
-        .ok()
-        .unwrap();
-
-    let pin_out = GpioPinUnitialized::new(1);
-    let pin_out = pin_out.open_for_write().ok().unwrap();
+fn test_gpio(console: &mut Console, pin_in: &GpioPinRead, pin_out: &mut GpioPinWrite) {
     pin_out.set_high().ok().unwrap();
 
     writeln!(console, "gpio_works = {}", pin_in.read()).unwrap();
 }
 
-async fn test_callbacks_and_wait_forever(console: &mut Console) -> TockResult<()> {
-    let mut with_callback = timer::with_callback(|_, _| {
+async fn test_callbacks_and_wait_forever(
+    console: &mut Console,
+    timer_context: &mut DriverContext,
+) -> TockResult<()> {
+    let mut with_callback = timer_context.with_callback(|_, _| {
         writeln!(console, "callbacks_work = true").unwrap();
         writeln!(console, "all_tests_run = true").unwrap();
     });
diff --git a/examples/hello.rs b/examples/hello.rs
index 5e4f987..3cbaf2f 100644
--- a/examples/hello.rs
+++ b/examples/hello.rs
@@ -1,16 +1,19 @@
 #![no_std]
 
 use core::fmt::Write;
-use libtock::console::Console;
 use libtock::result::TockResult;
-use libtock::timer;
 use libtock::timer::Duration;
+use libtock::Drivers;
 
 #[libtock::main]
 async fn main() -> TockResult<()> {
-    let mut console = Console::default();
-    let context = timer::DriverContext::create()?;
-    let mut driver = context.create_timer_driver()?;
+    let Drivers {
+        console_driver,
+        timer_context,
+        ..
+    } = libtock::retrieve_drivers()?;
+    let mut console = console_driver.create_console();
+    let mut driver = timer_context.create_timer_driver();
     let timer_driver = driver.activate()?;
 
     for i in 0.. {
diff --git a/examples/sensors.rs b/examples/sensors.rs
index 9936d31..4e72c8c 100644
--- a/examples/sensors.rs
+++ b/examples/sensors.rs
@@ -1,29 +1,35 @@
 #![no_std]
 
 use core::fmt::Write;
-use libtock::console::Console;
 use libtock::result::TockResult;
-use libtock::sensors::Ninedof;
 use libtock::sensors::*;
-use libtock::timer;
 use libtock::timer::Duration;
+use libtock::Drivers;
 
 #[libtock::main]
 async fn main() -> TockResult<()> {
-    let mut console = Console::default();
-    let mut humidity = HumiditySensor;
-    let mut temperature = TemperatureSensor;
-    let mut light = AmbientLightSensor;
-    let mut ninedof = Ninedof::default();
-    let context = timer::DriverContext::create()?;
-    let mut driver = context.create_timer_driver()?;
+    let Drivers {
+        console_driver,
+        timer_context,
+        mut temperature_sensor,
+        mut humidity_sensor,
+        mut ambient_light_sensor,
+        mut ninedof_driver,
+        ..
+    } = libtock::retrieve_drivers()?;
+    let mut console = console_driver.create_console();
+    let mut driver = timer_context.create_timer_driver();
     let timer_driver = driver.activate()?;
 
     loop {
-        writeln!(console, "Humidity:    {}\n", humidity.read()?)?;
-        writeln!(console, "Temperature: {}\n", temperature.read()?)?;
-        writeln!(console, "Light:       {}\n", light.read()?)?;
-        writeln!(console, "Accel:       {}\n", ninedof.read_acceleration()?)?;
+        writeln!(console, "Humidity:    {}\n", humidity_sensor.read()?)?;
+        writeln!(console, "Temperature: {}\n", temperature_sensor.read()?)?;
+        writeln!(console, "Light:       {}\n", ambient_light_sensor.read()?)?;
+        writeln!(
+            console,
+            "Accel:       {}\n",
+            ninedof_driver.read_acceleration()?
+        )?;
         timer_driver.sleep(Duration::from_ms(500)).await?;
     }
 }
diff --git a/examples/seven_segment.rs b/examples/seven_segment.rs
index cf884e4..4249157 100644
--- a/examples/seven_segment.rs
+++ b/examples/seven_segment.rs
@@ -1,10 +1,9 @@
 #![no_std]
 
 use libtock::electronics::ShiftRegister;
-use libtock::gpio::GpioPinUnitialized;
 use libtock::result::TockResult;
-use libtock::timer;
 use libtock::timer::Duration;
+use libtock::Drivers;
 
 fn number_to_bits(n: u8) -> [bool; 8] {
     match n {
@@ -25,14 +24,18 @@
 // Example works on a shift register on P0.03, P0.04, P0.28
 #[libtock::main]
 async fn main() -> TockResult<()> {
-    let shift_register = ShiftRegister::new(
-        GpioPinUnitialized::new(0).open_for_write()?,
-        GpioPinUnitialized::new(1).open_for_write()?,
-        GpioPinUnitialized::new(2).open_for_write()?,
+    let Drivers {
+        timer_context,
+        gpio_driver,
+        ..
+    } = libtock::retrieve_drivers()?;
+    let mut shift_register = ShiftRegister::new(
+        gpio_driver.pin(0)?.open_for_write()?,
+        gpio_driver.pin(1)?.open_for_write()?,
+        gpio_driver.pin(2)?.open_for_write()?,
     );
 
-    let context = timer::DriverContext::create()?;
-    let mut driver = context.create_timer_driver()?;
+    let mut driver = timer_context.create_timer_driver();
     let timer_driver = driver.activate()?;
 
     let mut i = 0;
diff --git a/examples/simple_ble.rs b/examples/simple_ble.rs
index 97511a0..e312ef5 100644
--- a/examples/simple_ble.rs
+++ b/examples/simple_ble.rs
@@ -2,11 +2,10 @@
 
 use libtock::ble_composer;
 use libtock::ble_composer::BlePayload;
-use libtock::led;
 use libtock::result::TockResult;
 use libtock::simple_ble::BleAdvertisingDriver;
-use libtock::timer;
 use libtock::timer::Duration;
+use libtock::Drivers;
 use serde::Serialize;
 
 #[derive(Serialize)]
@@ -17,7 +16,16 @@
 
 #[libtock::main]
 async fn main() -> TockResult<()> {
-    let led = led::get(0).unwrap();
+    let Drivers {
+        led_driver_factory,
+        timer_context,
+        mut ble_advertising_driver,
+        ..
+    } = libtock::retrieve_drivers()?;
+
+    let led_driver = led_driver_factory.create_driver()?;
+
+    let led = led_driver.get(0).unwrap();
 
     let uuid: [u8; 2] = [0x00, 0x18];
 
@@ -38,10 +46,9 @@
         .unwrap();
     gap_payload.add_service_payload([91, 79], &payload).unwrap();
 
-    let _handle = BleAdvertisingDriver::initialize(100, &gap_payload, &mut buffer);
+    let _handle = ble_advertising_driver.initialize(100, &gap_payload, &mut buffer);
 
-    let context = timer::DriverContext::create()?;
-    let mut driver = context.create_timer_driver()?;
+    let mut driver = timer_context.create_timer_driver();
     let timer_driver = driver.activate()?;
 
     loop {
diff --git a/examples/temperature.rs b/examples/temperature.rs
index 8a3eef0..9198f1b 100644
--- a/examples/temperature.rs
+++ b/examples/temperature.rs
@@ -1,13 +1,17 @@
 #![no_std]
 
 use core::fmt::Write;
-use libtock::console::Console;
 use libtock::result::TockResult;
-use libtock::temperature;
+use libtock::Drivers;
 
 #[libtock::main]
 async fn main() -> TockResult<()> {
-    let mut console = Console::default();
-    let temperature = temperature::measure_temperature().await?;
+    let Drivers {
+        console_driver,
+        mut temperature_driver,
+        ..
+    } = libtock::retrieve_drivers()?;
+    let mut console = console_driver.create_console();
+    let temperature = temperature_driver.measure_temperature().await?;
     writeln!(console, "Temperature: {}", temperature).map_err(Into::into)
 }
diff --git a/examples/timer_parallel.rs b/examples/timer_parallel.rs
index c19e583..389727a 100644
--- a/examples/timer_parallel.rs
+++ b/examples/timer_parallel.rs
@@ -1,19 +1,19 @@
 #![no_std]
 
 use futures::future;
-use libtock::led;
+use libtock::led::Led;
 use libtock::result::TockResult;
-use libtock::timer;
 use libtock::timer::Duration;
 use libtock::timer::ParallelSleepDriver;
+use libtock::Drivers;
 
 async fn blink<'a>(
     timer_driver: &'a ParallelSleepDriver<'a>,
     duration: Duration<usize>,
-    led_number: usize,
+    led: &'a mut Led<'a>,
 ) -> TockResult<()> {
     loop {
-        led::get(led_number).unwrap().toggle()?;
+        led.toggle()?;
 
         timer_driver.sleep(duration).await?;
     }
@@ -21,13 +21,24 @@
 
 #[libtock::main]
 async fn main() -> TockResult<()> {
-    let context = timer::DriverContext::create()?;
-    let mut driver = context.create_timer_driver()?;
+    let Drivers {
+        led_driver_factory,
+        timer_context,
+        ..
+    } = libtock::retrieve_drivers()?;
+    let led_driver = led_driver_factory.create_driver()?;
+
+    let mut led_iter = led_driver.all();
+    let mut led_1 = led_iter.next().unwrap();
+    let mut led_2 = led_iter.next().unwrap();
+    let mut led_3 = led_iter.next().unwrap();
+
+    let mut driver = timer_context.create_timer_driver();
     let timer_driver = driver.activate()?;
 
-    let fut_1 = blink(&timer_driver, Duration::from_ms(500), 0);
-    let fut_2 = blink(&timer_driver, Duration::from_ms(333), 1);
-    let fut_3 = blink(&timer_driver, Duration::from_ms(250), 2);
+    let fut_1 = blink(&timer_driver, Duration::from_ms(500), &mut led_1);
+    let fut_2 = blink(&timer_driver, Duration::from_ms(333), &mut led_2);
+    let fut_3 = blink(&timer_driver, Duration::from_ms(250), &mut led_3);
 
     future::try_join3(fut_1, fut_2, fut_3).await?;
     Ok(())
diff --git a/examples/timer_subscribe.rs b/examples/timer_subscribe.rs
index 11afdfd..f7e158c 100644
--- a/examples/timer_subscribe.rs
+++ b/examples/timer_subscribe.rs
@@ -2,16 +2,19 @@
 
 use core::fmt::Write;
 use futures::future;
-use libtock::console::Console;
 use libtock::result::TockResult;
-use libtock::timer;
 use libtock::timer::Duration;
+use libtock::Drivers;
 
 #[libtock::main]
 async fn main() -> TockResult<()> {
-    let mut console = Console::default();
-
-    let mut with_callback = timer::with_callback(|_, _| {
+    let Drivers {
+        console_driver,
+        mut timer_context,
+        ..
+    } = libtock::retrieve_drivers()?;
+    let mut console = console_driver.create_console();
+    let mut with_callback = timer_context.with_callback(|_, _| {
         writeln!(
             console,
             "This line is printed 2 seconds after the start of the program.",
diff --git a/run_all_checks.sh b/run_all_checks.sh
new file mode 100755
index 0000000..7d96180
--- /dev/null
+++ b/run_all_checks.sh
@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+
+set -eux
+
+cargo fmt --all -- --check
+cargo test --workspace
+cargo clippy --workspace --all-targets
+./build_examples.sh
diff --git a/src/adc.rs b/src/adc.rs
index ecb18df..7a18cce 100644
--- a/src/adc.rs
+++ b/src/adc.rs
@@ -6,7 +6,7 @@
 pub const DRIVER_NUM: usize = 0x0005;
 pub const BUFFER_SIZE: usize = 128;
 
-mod command {
+mod command_nr {
     pub const COUNT: usize = 0;
     pub const START: usize = 1;
     pub const START_REPEAT: usize = 2;
@@ -15,15 +15,24 @@
     pub const STOP: usize = 5;
 }
 
-mod subscribe {
+mod subscribe_nr {
     pub const SUBSCRIBE_CALLBACK: usize = 0;
 }
 
-mod allow {
+mod allow_nr {
     pub const BUFFER: usize = 0;
     pub const BUFFER_ALT: usize = 1;
 }
 
+#[non_exhaustive]
+pub struct AdcDriver;
+
+impl AdcDriver {
+    pub fn with_callback<CB>(self, callback: CB) -> WithCallback<CB> {
+        WithCallback { callback }
+    }
+}
+
 pub struct AdcBuffer {
     // TODO: make this generic if possible with the driver impl
     buffer: [u8; BUFFER_SIZE],
@@ -43,10 +52,6 @@
     subscription: CallbackSubscription<'a>,
 }
 
-pub fn with_callback<CB>(callback: CB) -> WithCallback<CB> {
-    WithCallback { callback }
-}
-
 pub struct WithCallback<CB> {
     callback: CB,
 }
@@ -63,8 +68,8 @@
 {
     pub fn init(&mut self) -> TockResult<Adc> {
         let adc = Adc {
-            count: syscalls::command(DRIVER_NUM, command::COUNT, 0, 0)?,
-            subscription: syscalls::subscribe(DRIVER_NUM, subscribe::SUBSCRIBE_CALLBACK, self)?,
+            count: syscalls::command(DRIVER_NUM, command_nr::COUNT, 0, 0)?,
+            subscription: syscalls::subscribe(DRIVER_NUM, subscribe_nr::SUBSCRIBE_CALLBACK, self)?,
         };
         Ok(adc)
     }
@@ -72,11 +77,12 @@
 
 impl<'a> Adc<'a> {
     pub fn init_buffer(buffer: &'a mut AdcBuffer) -> TockResult<SharedMemory> {
-        syscalls::allow(DRIVER_NUM, allow::BUFFER, &mut buffer.buffer).map_err(Into::into)
+        syscalls::allow(DRIVER_NUM, allow_nr::BUFFER, &mut buffer.buffer).map_err(Into::into)
     }
 
     pub fn init_alt_buffer(alt_buffer: &'a mut AdcBuffer) -> TockResult<SharedMemory> {
-        syscalls::allow(DRIVER_NUM, allow::BUFFER_ALT, &mut alt_buffer.buffer).map_err(Into::into)
+        syscalls::allow(DRIVER_NUM, allow_nr::BUFFER_ALT, &mut alt_buffer.buffer)
+            .map_err(Into::into)
     }
 
     /// Return the number of available channels
@@ -86,19 +92,24 @@
 
     /// Start a single sample of channel
     pub fn sample(&self, channel: usize) -> TockResult<()> {
-        syscalls::command(DRIVER_NUM, command::START, channel, 0)?;
+        syscalls::command(DRIVER_NUM, command_nr::START, channel, 0)?;
         Ok(())
     }
 
     /// Start continuous sampling of channel
     pub fn sample_continuous(&self, channel: usize) -> TockResult<()> {
-        syscalls::command(DRIVER_NUM, command::START_REPEAT, channel, 0)?;
+        syscalls::command(DRIVER_NUM, command_nr::START_REPEAT, channel, 0)?;
         Ok(())
     }
 
     /// Start continuous sampling to first buffer
     pub fn sample_continuous_buffered(&self, channel: usize, frequency: usize) -> TockResult<()> {
-        syscalls::command(DRIVER_NUM, command::START_REPEAT_BUFFER, channel, frequency)?;
+        syscalls::command(
+            DRIVER_NUM,
+            command_nr::START_REPEAT_BUFFER,
+            channel,
+            frequency,
+        )?;
         Ok(())
     }
 
@@ -110,7 +121,7 @@
     ) -> TockResult<()> {
         syscalls::command(
             DRIVER_NUM,
-            command::START_REPEAT_BUFFER_ALT,
+            command_nr::START_REPEAT_BUFFER_ALT,
             channel,
             frequency,
         )?;
@@ -119,7 +130,7 @@
 
     /// Stop any started sampling operation
     pub fn stop(&self) -> TockResult<()> {
-        syscalls::command(DRIVER_NUM, command::STOP, 0, 0)?;
+        syscalls::command(DRIVER_NUM, command_nr::STOP, 0, 0)?;
         Ok(())
     }
 }
diff --git a/src/buttons.rs b/src/buttons.rs
index c360f7a..7004cd8 100644
--- a/src/buttons.rs
+++ b/src/buttons.rs
@@ -17,8 +17,13 @@
     pub const SUBSCRIBE_CALLBACK: usize = 0;
 }
 
-pub fn with_callback<CB>(callback: CB) -> WithCallback<CB> {
-    WithCallback { callback }
+#[non_exhaustive]
+pub struct ButtonDriver;
+
+impl ButtonDriver {
+    pub fn with_callback<CB>(self, callback: CB) -> WithCallback<CB> {
+        WithCallback { callback }
+    }
 }
 
 pub struct WithCallback<CB> {
diff --git a/src/console.rs b/src/console.rs
index bfcd6d7..b4f2c51 100644
--- a/src/console.rs
+++ b/src/console.rs
@@ -20,6 +20,17 @@
     pub const SHARE_BUFFER: usize = 1;
 }
 
+#[non_exhaustive]
+pub struct ConsoleDriver;
+
+impl ConsoleDriver {
+    pub fn create_console(self) -> Console {
+        Console {
+            allow_buffer: [0; 64],
+        }
+    }
+}
+
 pub struct Console {
     allow_buffer: [u8; 64],
 }
@@ -63,14 +74,6 @@
     }
 }
 
-impl Default for Console {
-    fn default() -> Self {
-        Console {
-            allow_buffer: [0; 64],
-        }
-    }
-}
-
 impl fmt::Write for Console {
     fn write_str(&mut self, string: &str) -> Result<(), fmt::Error> {
         self.write(string).map_err(|_| fmt::Error)
diff --git a/src/debug/mod.rs b/src/debug/mod.rs
index f67ae9b..1e55bb3 100644
--- a/src/debug/mod.rs
+++ b/src/debug/mod.rs
@@ -1,20 +1,23 @@
 //! Heapless debugging functions for Tock troubleshooting
 
 mod low_level_debug;
+use crate::drivers::Drivers;
 pub use low_level_debug::*;
 
-use crate::console::Console;
+use crate::retrieve_drivers_unsafe;
 
 pub fn println() {
     let buffer = [b'\n'];
-    let mut console = Console::default();
+    let Drivers { console_driver, .. } = unsafe { retrieve_drivers_unsafe() };
+    let mut console = console_driver.create_console();
     let _ = console.write(&buffer);
 }
 
 pub fn print_as_hex(value: usize) {
     let mut buffer = [b'\n'; 11];
     write_as_hex(&mut buffer, value);
-    let mut console = Console::default();
+    let Drivers { console_driver, .. } = unsafe { retrieve_drivers_unsafe() };
+    let mut console = console_driver.create_console();
     let _ = console.write(buffer);
 }
 
@@ -26,7 +29,8 @@
     let mut buffer = [b'\n'; 15];
     buffer[0..4].clone_from_slice(b"SP: ");
     write_as_hex(&mut buffer[4..15], stack_pointer);
-    let mut console = Console::default();
+    let Drivers { console_driver, .. } = unsafe { retrieve_drivers_unsafe() };
+    let mut console = console_driver.create_console();
     let _ = console.write(buffer);
 }
 
@@ -50,7 +54,8 @@
         }
     }
     buffer[27] = b'\n';
-    let mut console = Console::default();
+    let Drivers { console_driver, .. } = retrieve_drivers_unsafe();
+    let mut console = console_driver.create_console();
     let _ = console.write(&buffer);
 }
 
diff --git a/src/drivers.rs b/src/drivers.rs
new file mode 100644
index 0000000..814f61b
--- /dev/null
+++ b/src/drivers.rs
@@ -0,0 +1,97 @@
+use crate::adc::AdcDriver;
+use crate::buttons::ButtonDriver;
+use crate::console::ConsoleDriver;
+use crate::gpio::GpioDriver;
+use crate::led::LedDriverFactory;
+use crate::result::OtherError;
+use crate::result::TockError;
+use crate::result::TockResult;
+use crate::rng::RngDriver;
+use crate::sensors::ninedof::NinedofDriver;
+use crate::sensors::AmbientLightSensor;
+use crate::sensors::HumiditySensor;
+use crate::sensors::TemperatureSensor;
+use crate::simple_ble::BleAdvertisingDriver;
+use crate::simple_ble::BleScanningDriver;
+use crate::temperature::TemperatureDriver;
+use crate::timer::DriverContext;
+use core::cell::Cell;
+
+/// Struct containing all drivers constructible through [retrieve_drivers()]
+#[non_exhaustive]
+pub struct Drivers {
+    pub console_driver: ConsoleDriver,
+    pub led_driver_factory: LedDriverFactory,
+    pub timer_context: DriverContext,
+    pub gpio_driver: GpioDriver,
+    pub temperature_driver: TemperatureDriver,
+    pub button_driver: ButtonDriver,
+    pub adc_driver: AdcDriver,
+    pub rng_driver: RngDriver,
+    pub ble_advertising_driver: BleAdvertisingDriver,
+    pub ble_scanning_driver: BleScanningDriver,
+    pub ambient_light_sensor: AmbientLightSensor,
+    pub temperature_sensor: TemperatureSensor,
+    pub humidity_sensor: HumiditySensor,
+    pub ninedof_driver: NinedofDriver,
+}
+
+/// Retrieve [Drivers] struct. Returns struct only once.
+pub fn retrieve_drivers() -> TockResult<Drivers> {
+    match unsafe { DRIVERS_SINGLETON.take() } {
+        Some(drivers) => Ok(drivers),
+        None => Err(TockError::Other(OtherError::DriverAlreadyTaken)),
+    }
+}
+
+/// Retrieve [Drivers] struct without check whether it has already been taken
+/// at a different point.
+/// # Safety
+/// This shall only used in special situations where drivers cannot be passed as arguments
+/// as in the panic handler. Otherwise global mutable state (as shared buffers) may be exposed
+/// in an unsafe manner.
+pub unsafe fn retrieve_drivers_unsafe() -> Drivers {
+    DRIVERS
+}
+
+#[allow(clippy::declare_interior_mutable_const)]
+const DRIVERS: Drivers = Drivers {
+    adc_driver: AdcDriver,
+    ble_advertising_driver: BleAdvertisingDriver,
+    ble_scanning_driver: BleScanningDriver,
+    button_driver: ButtonDriver,
+    console_driver: ConsoleDriver,
+    led_driver_factory: LedDriverFactory,
+    timer_context: DriverContext {
+        active_timer: Cell::new(None),
+    },
+    gpio_driver: GpioDriver,
+    temperature_driver: TemperatureDriver,
+    rng_driver: RngDriver,
+    ambient_light_sensor: AmbientLightSensor,
+    temperature_sensor: TemperatureSensor,
+    humidity_sensor: HumiditySensor,
+    ninedof_driver: NinedofDriver,
+};
+
+static mut DRIVERS_SINGLETON: Option<Drivers> = Some(DRIVERS);
+
+#[cfg(test)]
+mod test {
+    use super::DRIVERS;
+    use super::DRIVERS_SINGLETON;
+    use crate::retrieve_drivers;
+    #[test]
+    pub fn can_be_retrieved_once() {
+        reset_drivers_singleton();
+
+        assert!(retrieve_drivers().is_ok());
+        assert!(retrieve_drivers().is_err());
+    }
+
+    fn reset_drivers_singleton() {
+        unsafe {
+            DRIVERS_SINGLETON = Some(DRIVERS);
+        };
+    }
+}
diff --git a/src/electronics/shift_register.rs b/src/electronics/shift_register.rs
index f170225..10eac0d 100644
--- a/src/electronics/shift_register.rs
+++ b/src/electronics/shift_register.rs
@@ -1,18 +1,18 @@
 use crate::gpio::GpioPinWrite;
 use crate::result::TockResult;
 
-pub struct ShiftRegister {
-    data_pin: GpioPinWrite,
-    clock_pin: GpioPinWrite,
-    latch_pin: GpioPinWrite,
+pub struct ShiftRegister<'a> {
+    data_pin: GpioPinWrite<'a>,
+    clock_pin: GpioPinWrite<'a>,
+    latch_pin: GpioPinWrite<'a>,
 }
 
-impl ShiftRegister {
+impl<'a> ShiftRegister<'a> {
     pub fn new(
-        data_pin: GpioPinWrite,
-        clock_pin: GpioPinWrite,
-        latch_pin: GpioPinWrite,
-    ) -> ShiftRegister {
+        data_pin: GpioPinWrite<'a>,
+        clock_pin: GpioPinWrite<'a>,
+        latch_pin: GpioPinWrite<'a>,
+    ) -> ShiftRegister<'a> {
         ShiftRegister {
             data_pin,
             clock_pin,
@@ -20,14 +20,14 @@
         }
     }
 
-    pub fn write_bits(&self, values: &[bool]) -> TockResult<()> {
+    pub fn write_bits(&mut self, values: &[bool]) -> TockResult<()> {
         for i in values {
             self.push_bit(*i)?;
         }
         self.display()
     }
 
-    fn push_bit(&self, value: bool) -> TockResult<()> {
+    fn push_bit(&mut self, value: bool) -> TockResult<()> {
         if value {
             self.data_pin.set_high()
         } else {
@@ -37,7 +37,7 @@
         self.clock_pin.set_low()
     }
 
-    fn display(&self) -> TockResult<()> {
+    fn display(&mut self) -> TockResult<()> {
         self.latch_pin.set_high()?;
         self.latch_pin.set_low()
     }
diff --git a/src/gpio.rs b/src/gpio.rs
index d416632..6f87e44 100644
--- a/src/gpio.rs
+++ b/src/gpio.rs
@@ -1,9 +1,12 @@
+use crate::result::OtherError;
+use crate::result::TockError;
 use crate::result::TockResult;
 use crate::syscalls;
+use core::marker::PhantomData;
 
 const DRIVER_NUMBER: usize = 0x00004;
-mod gpio_commands {
-    pub const SUBSCRIBE_CALLBACK: usize = 0;
+mod command_nr {
+    pub const NUMBER_PINS: usize = 0;
     pub const ENABLE_OUTPUT: usize = 1;
     pub const SET_HIGH: usize = 2;
     pub const SET_LOW: usize = 3;
@@ -15,6 +18,64 @@
     pub const DISABLE: usize = 9;
 }
 
+mod subscribe_nr {
+    pub const SUBSCRIBE_CALLBACK: usize = 0;
+}
+
+#[non_exhaustive]
+pub struct GpioDriver;
+
+impl GpioDriver {
+    pub fn all_pins<'a>(&'a self) -> TockResult<GpioIter<'a>> {
+        let number = self.number_of_pins()?;
+        Ok(GpioIter {
+            curr_gpio: 0,
+            gpio_count: number,
+            phantom: PhantomData,
+        })
+    }
+
+    pub fn pin<'a>(&'a self, pin: usize) -> TockResult<GpioPinUnitialized<'a>> {
+        let number = self.number_of_pins()?;
+        if pin < number {
+            Ok(GpioPinUnitialized {
+                number: pin,
+                phantom: PhantomData,
+            })
+        } else {
+            Err(TockError::Other(OtherError::NotEnoughGpioPins))
+        }
+    }
+
+    fn number_of_pins(&self) -> TockResult<usize> {
+        syscalls::command(DRIVER_NUMBER, command_nr::NUMBER_PINS, 0, 0).map_err(Into::into)
+    }
+}
+
+#[derive(Copy, Clone)]
+pub struct GpioIter<'a> {
+    curr_gpio: usize,
+    gpio_count: usize,
+    phantom: PhantomData<&'a mut ()>,
+}
+
+impl<'a> Iterator for GpioIter<'a> {
+    type Item = GpioPinUnitialized<'a>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.curr_gpio < self.gpio_count {
+            let item = GpioPinUnitialized {
+                number: self.curr_gpio,
+                phantom: PhantomData,
+            };
+            self.curr_gpio += 1;
+            Some(item)
+        } else {
+            None
+        }
+    }
+}
+
 pub enum InputMode {
     PullUp,
     PullDown,
@@ -47,27 +108,27 @@
     }
 }
 
-pub struct GpioPinUnitialized {
+pub struct GpioPinUnitialized<'a> {
     number: usize,
+    phantom: PhantomData<&'a mut ()>,
 }
 
-pub struct GpioPinWrite {
+pub struct GpioPinWrite<'a> {
     number: usize,
+    phantom: PhantomData<&'a mut ()>,
 }
 
-pub struct GpioPinRead {
+pub struct GpioPinRead<'a> {
     number: usize,
+    phantom: PhantomData<&'a mut ()>,
 }
 
-impl GpioPinUnitialized {
-    pub fn new(number: usize) -> GpioPinUnitialized {
-        GpioPinUnitialized { number }
-    }
-
-    pub fn open_for_write(self) -> TockResult<GpioPinWrite> {
-        syscalls::command(DRIVER_NUMBER, gpio_commands::ENABLE_OUTPUT, self.number, 0)?;
+impl<'a> GpioPinUnitialized<'a> {
+    pub fn open_for_write(self) -> TockResult<GpioPinWrite<'a>> {
+        syscalls::command(DRIVER_NUMBER, command_nr::ENABLE_OUTPUT, self.number, 0)?;
         Ok(GpioPinWrite {
             number: self.number,
+            phantom: PhantomData,
         })
     }
 
@@ -75,85 +136,81 @@
         self,
         callback: Option<(extern "C" fn(usize, usize, usize, usize), IrqMode)>,
         input_mode: InputMode,
-    ) -> TockResult<GpioPinRead> {
+    ) -> TockResult<GpioPinRead<'a>> {
         let (callback, irq_mode) = callback.unwrap_or((noop_callback, IrqMode::EitherEdge));
         self.enable_input(input_mode)
             .and_then(|pin| pin.subscribe_callback(callback))
-            .and_then(|pin| pin.enable_callback(irq_mode))
+            .and_then(move |pin| pin.enable_callback(irq_mode))
     }
 
     fn subscribe_callback(
         self,
         callback: extern "C" fn(usize, usize, usize, usize),
-    ) -> TockResult<GpioPinUnitialized> {
+    ) -> TockResult<GpioPinUnitialized<'a>> {
         syscalls::subscribe_fn(
             DRIVER_NUMBER,
-            gpio_commands::SUBSCRIBE_CALLBACK,
+            subscribe_nr::SUBSCRIBE_CALLBACK,
             callback,
             self.number,
         )?;
         Ok(self)
     }
 
-    fn enable_input(self, mode: InputMode) -> TockResult<GpioPinUnitialized> {
+    fn enable_input(self, mode: InputMode) -> TockResult<GpioPinUnitialized<'a>> {
         syscalls::command(
             DRIVER_NUMBER,
-            gpio_commands::ENABLE_INPUT,
+            command_nr::ENABLE_INPUT,
             self.number,
             mode.to_num(),
         )?;
         Ok(self)
     }
 
-    fn enable_callback(self, irq_mode: IrqMode) -> TockResult<GpioPinRead> {
+    fn enable_callback(self, irq_mode: IrqMode) -> TockResult<GpioPinRead<'a>> {
         syscalls::command(
             DRIVER_NUMBER,
-            gpio_commands::ENABLE_INTERRUPT,
+            command_nr::ENABLE_INTERRUPT,
             self.number,
             irq_mode.to_num(),
         )?;
         Ok(GpioPinRead {
             number: self.number,
+            phantom: PhantomData,
         })
     }
 }
 
-impl GpioPinWrite {
+impl<'a> GpioPinWrite<'a> {
     pub fn set_low(&self) -> TockResult<()> {
-        syscalls::command(DRIVER_NUMBER, gpio_commands::SET_LOW, self.number, 0)?;
+        syscalls::command(DRIVER_NUMBER, command_nr::SET_LOW, self.number, 0)?;
         Ok(())
     }
     pub fn set_high(&self) -> TockResult<()> {
-        syscalls::command(DRIVER_NUMBER, gpio_commands::SET_HIGH, self.number, 0)?;
+        syscalls::command(DRIVER_NUMBER, command_nr::SET_HIGH, self.number, 0)?;
         Ok(())
     }
     pub fn toggle(&self) -> TockResult<()> {
-        syscalls::command(DRIVER_NUMBER, gpio_commands::TOGGLE, self.number, 0)?;
+        syscalls::command(DRIVER_NUMBER, command_nr::TOGGLE, self.number, 0)?;
         Ok(())
     }
 }
 
-impl GpioPinRead {
-    pub fn read(&self) -> bool {
-        syscalls::command(DRIVER_NUMBER, gpio_commands::READ, self.number, 0).ok() == Some(1)
+impl<'a> GpioPinRead<'a> {
+    pub fn read(&'a self) -> bool {
+        syscalls::command(DRIVER_NUMBER, command_nr::READ, self.number, 0).ok() == Some(1)
     }
 }
 
-impl Drop for GpioPinWrite {
+impl<'a> Drop for GpioPinWrite<'a> {
     fn drop(&mut self) {
-        let _ = syscalls::command(DRIVER_NUMBER, gpio_commands::DISABLE, self.number, 0);
+        let _ = syscalls::command(DRIVER_NUMBER, command_nr::DISABLE, self.number, 0);
     }
 }
 
-impl Drop for GpioPinRead {
+impl<'a> Drop for GpioPinRead<'a> {
     fn drop(&mut self) {
-        let _ = syscalls::command(
-            DRIVER_NUMBER,
-            gpio_commands::DISABLE_INTERRUPT,
-            self.number,
-            0,
-        );
-        let _ = syscalls::command(DRIVER_NUMBER, gpio_commands::DISABLE, self.number, 0);
+        let _ = syscalls::command(DRIVER_NUMBER, command_nr::DISABLE_INTERRUPT, self.number, 0);
+        let _ = syscalls::command(DRIVER_NUMBER, command_nr::DISABLE, self.number, 0);
     }
 }
 
diff --git a/src/lang_items.rs b/src/lang_items.rs
index 197de47..6ff7529 100644
--- a/src/lang_items.rs
+++ b/src/lang_items.rs
@@ -18,9 +18,10 @@
 //! `rustc_main`. That's covered by the `_start` function in the root of this
 //! crate.
 
-use crate::led;
-use crate::timer;
+use crate::led::LedDriver;
 use crate::timer::Duration;
+use crate::timer::ParallelSleepDriver;
+use crate::Drivers;
 use core::alloc::Layout;
 use core::executor;
 use core::panic::PanicInfo;
@@ -47,49 +48,63 @@
 
     // Flash all LEDs (if available).
     executor::block_on(async {
-        let context = timer::DriverContext::create().ok();
-        let mut driver = context.as_ref().map(|c| c.create_timer_driver_unsafe());
-        let timer_driver = driver.as_mut().and_then(|d| d.activate().ok());
-        loop {
-            for led in led::all() {
-                let _ = led.on();
-            }
-            if let Some(ref timer_driver) = timer_driver {
-                let _ = timer_driver.sleep(Duration::from_ms(100)).await;
-            }
-            for led in led::all() {
-                let _ = led.off();
-            }
-            if let Some(ref timer_driver) = timer_driver {
-                let _ = timer_driver.sleep(Duration::from_ms(100)).await;
-            }
+        let Drivers {
+            led_driver_factory,
+            timer_context,
+            ..
+        } = crate::retrieve_drivers_unsafe();
+        let mut driver = timer_context.create_timer_driver();
+        let timer_driver = driver.activate().ok();
+        let led_driver = led_driver_factory.create_driver().ok();
+        if let (Some(ref led_driver), Some(ref timer_driver)) = (led_driver, timer_driver) {
+            blink_all_leds(timer_driver, led_driver).await;
         }
+        loop {}
     });
     // Never type is not supported for T in Future
     unreachable!()
 }
 
-#[alloc_error_handler]
-unsafe fn cycle_leds(_: Layout) -> ! {
-    executor::block_on(async {
-        let context = timer::DriverContext::create().ok();
-        let mut driver = context.as_ref().map(|c| c.create_timer_driver_unsafe());
-        let timer_driver = driver.as_mut().and_then(|d| d.activate().ok());
-        loop {
-            for led in led::all() {
-                let _ = led.on();
-            }
-            if let Some(ref timer_driver) = timer_driver {
-                let _ = timer_driver.sleep(Duration::from_ms(100)).await;
-            }
-            for led in led::all() {
-                let _ = led.off();
-            }
-            if let Some(ref timer_driver) = timer_driver {
-                let _ = timer_driver.sleep(Duration::from_ms(100)).await;
-            }
+async fn blink_all_leds(timer_driver: &ParallelSleepDriver<'_>, led_driver: &LedDriver) {
+    loop {
+        for led in led_driver.all() {
+            let _ = led.on();
         }
+        let _ = timer_driver.sleep(Duration::from_ms(100)).await;
+        for led in led_driver.all() {
+            let _ = led.off();
+        }
+        let _ = timer_driver.sleep(Duration::from_ms(100)).await;
+    }
+}
+
+#[alloc_error_handler]
+unsafe fn alloc_error_handler(_: Layout) -> ! {
+    executor::block_on(async {
+        let Drivers {
+            led_driver_factory,
+            timer_context,
+            ..
+        } = crate::retrieve_drivers_unsafe();
+        let mut driver = timer_context.create_timer_driver();
+        let timer_driver = driver.activate().ok();
+        let led_driver = led_driver_factory.create_driver().ok();
+
+        if let (Some(led_driver), Some(timer_driver)) = (led_driver, timer_driver) {
+            cycle_all_leds(&timer_driver, &led_driver).await;
+        }
+        loop {}
     });
     // Never type is not supported for T in Future
     unreachable!()
 }
+
+async fn cycle_all_leds(timer_driver: &ParallelSleepDriver<'_>, led_driver: &LedDriver) {
+    loop {
+        for led in led_driver.all() {
+            let _ = led.on();
+            let _ = timer_driver.sleep(Duration::from_ms(100)).await;
+            let _ = led.off();
+        }
+    }
+}
diff --git a/src/led.rs b/src/led.rs
index d7aac8f..6e69944 100644
--- a/src/led.rs
+++ b/src/led.rs
@@ -1,5 +1,6 @@
 use crate::result::TockResult;
 use crate::syscalls::command;
+use core::marker::PhantomData;
 
 const DRIVER_NUMBER: usize = 0x00002;
 
@@ -10,32 +11,53 @@
     pub const TOGGLE: usize = 3;
 }
 
-pub struct Led {
+#[non_exhaustive]
+pub struct LedDriverFactory;
+
+impl LedDriverFactory {
+    pub fn create_driver(self) -> TockResult<LedDriver> {
+        command(DRIVER_NUMBER, command_nr::COUNT, 0, 0)?;
+        Ok(LedDriver)
+    }
+}
+
+#[non_exhaustive]
+pub struct LedDriver;
+
+pub struct Led<'a> {
     led_num: usize,
+    phantom: PhantomData<&'a mut ()>,
 }
 
-pub fn count() -> TockResult<usize> {
-    command(DRIVER_NUMBER, command_nr::COUNT, 0, 0).map_err(Into::into)
-}
+impl LedDriver {
+    pub fn get(&self, led_num: usize) -> Option<Led> {
+        if led_num < self.count().ok().unwrap() {
+            Some(Led {
+                led_num,
+                phantom: PhantomData,
+            })
+        } else {
+            None
+        }
+    }
 
-pub fn get(led_num: usize) -> Option<Led> {
-    if led_num < count().ok().unwrap() {
-        Some(Led { led_num })
-    } else {
-        None
+    pub fn count(&self) -> TockResult<usize> {
+        command(DRIVER_NUMBER, command_nr::COUNT, 0, 0).map_err(Into::into)
+    }
+
+    pub fn all(&self) -> LedIter {
+        LedIter {
+            curr_led: 0,
+            led_count: self.count().unwrap_or(0),
+            phantom: PhantomData,
+        }
     }
 }
 
 /// Returns an iterator over all available LEDs. If the LED driver is not
 /// present, the iterator will be empty.
-pub fn all() -> LedIter {
-    LedIter {
-        curr_led: 0,
-        led_count: count().unwrap_or(0),
-    }
-}
 
-impl Led {
+impl<'a> Led<'a> {
     pub fn set_state(&self, state: bool) -> TockResult<()> {
         if state {
             self.on()
@@ -58,21 +80,27 @@
         command(DRIVER_NUMBER, command_nr::TOGGLE, self.led_num, 0)?;
         Ok(())
     }
+
+    pub fn number(&self) -> usize {
+        self.led_num
+    }
 }
 
 #[derive(Copy, Clone)]
-pub struct LedIter {
+pub struct LedIter<'a> {
     curr_led: usize,
     led_count: usize,
+    phantom: PhantomData<&'a mut ()>,
 }
 
-impl Iterator for LedIter {
-    type Item = Led;
+impl<'a> Iterator for LedIter<'a> {
+    type Item = Led<'a>;
 
     fn next(&mut self) -> Option<Self::Item> {
         if self.curr_led < self.led_count {
             let item = Led {
                 led_num: self.curr_led,
+                phantom: PhantomData,
             };
             self.curr_led += 1;
             Some(item)
diff --git a/src/lib.rs b/src/lib.rs
index 8873c33..1c1ecf0 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -33,6 +33,9 @@
 
 pub use libtock_codegen::main;
 
-// Dummy structure to force importing the panic_handler and other no_std elements when nothing else
-// is imported.
+pub(crate) mod drivers;
+pub use drivers::*;
+
+/// Dummy structure to force importing the panic_handler and other no_std elements when nothing else
+/// is imported.
 pub struct LibTock;
diff --git a/src/result.rs b/src/result.rs
index 4eaec21..f3929ca 100644
--- a/src/result.rs
+++ b/src/result.rs
@@ -70,6 +70,7 @@
     TimerDriverDurationOutOfRange,
     TimerDriverErroneousClockFrequency,
     DriverAlreadyTaken,
+    NotEnoughGpioPins,
 }
 
 impl From<OtherError> for TockError {
diff --git a/src/rng.rs b/src/rng.rs
index 2134fb2..e04500f 100644
--- a/src/rng.rs
+++ b/src/rng.rs
@@ -18,25 +18,24 @@
     pub const SHARE_BUFFER: usize = 0;
 }
 
-pub async fn fill_buffer(buf: &mut [u8]) -> TockResult<()> {
-    let buf_len = buf.len();
+#[non_exhaustive]
+pub struct RngDriver;
 
-    let shared_memory = syscalls::allow(DRIVER_NUMBER, allow_nr::SHARE_BUFFER, buf)?;
-
-    let is_filled = Cell::new(false);
-    let mut is_filled_alarm = |_, _, _| is_filled.set(true);
-    let subscription = syscalls::subscribe(
-        DRIVER_NUMBER,
-        subscribe_nr::BUFFER_FILLED,
-        &mut is_filled_alarm,
-    )?;
-
-    syscalls::command(DRIVER_NUMBER, command_nr::REQUEST_RNG, buf_len, 0)?;
-
-    futures::wait_until(|| is_filled.get()).await;
-
-    mem::drop(subscription);
-    mem::drop(shared_memory);
-
-    Ok(())
+impl RngDriver {
+    pub async fn fill_buffer(&mut self, buf: &mut [u8]) -> TockResult<()> {
+        let buf_len = buf.len();
+        let shared_memory = syscalls::allow(DRIVER_NUMBER, allow_nr::SHARE_BUFFER, buf)?;
+        let is_filled = Cell::new(false);
+        let mut is_filled_alarm = |_, _, _| is_filled.set(true);
+        let subscription = syscalls::subscribe(
+            DRIVER_NUMBER,
+            subscribe_nr::BUFFER_FILLED,
+            &mut is_filled_alarm,
+        )?;
+        syscalls::command(DRIVER_NUMBER, command_nr::REQUEST_RNG, buf_len, 0)?;
+        futures::wait_until(|| is_filled.get()).await;
+        mem::drop(subscription);
+        mem::drop(shared_memory);
+        Ok(())
+    }
 }
diff --git a/src/sensors/mod.rs b/src/sensors/mod.rs
index af7e00f..c4b962f 100644
--- a/src/sensors/mod.rs
+++ b/src/sensors/mod.rs
@@ -7,9 +7,7 @@
 use core::fmt;
 use core::mem;
 
-mod ninedof;
-
-pub use self::ninedof::*;
+pub mod ninedof;
 
 extern "C" fn cb<Reading>(x: usize, y: usize, z: usize, ptr: usize)
 where
@@ -36,20 +34,25 @@
 macro_rules! single_value_sensor {
     ($sensor_name:ident, $type_name:ident, $driver_num:expr) => {
         #[derive(Copy, Clone, Eq, PartialEq, Debug)]
-        pub struct $type_name(i32);
+        pub struct $type_name {
+            value: i32,
+        }
 
         impl From<(usize, usize, usize)> for $type_name {
             fn from(tuple: (usize, usize, usize)) -> $type_name {
-                $type_name(tuple.0 as i32)
+                $type_name {
+                    value: (tuple.0 as i32),
+                }
             }
         }
 
         impl Into<i32> for $type_name {
             fn into(self) -> i32 {
-                self.0
+                self.value
             }
         }
 
+        #[non_exhaustive]
         pub struct $sensor_name;
 
         impl Sensor<$type_name> for $sensor_name {
@@ -66,18 +69,18 @@
 
 impl fmt::Display for AmbientLight {
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
-        write!(f, "{} lx", self.0)
+        write!(f, "{} lx", self.value)
     }
 }
 
 impl fmt::Display for Humidity {
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
-        write!(f, "{}.{}%", self.0 / 100, self.0 % 100)
+        write!(f, "{}.{}%", self.value / 100, self.value % 100)
     }
 }
 
 impl fmt::Display for Temperature {
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
-        write!(f, "{}.{}\u{00B0}C", self.0 / 100, self.0 % 100)
+        write!(f, "{}.{}\u{00B0}C", self.value / 100, self.value % 100)
     }
 }
diff --git a/src/sensors/ninedof.rs b/src/sensors/ninedof.rs
index 7986a40..e468690 100644
--- a/src/sensors/ninedof.rs
+++ b/src/sensors/ninedof.rs
@@ -8,7 +8,8 @@
 
 const DRIVER_NUM: usize = 0x60004;
 
-pub struct Ninedof;
+#[non_exhaustive]
+pub struct NinedofDriver;
 
 #[derive(Copy, Clone, Default, Debug)]
 pub struct NinedofReading {
@@ -29,7 +30,7 @@
     ready: Cell<bool>,
 }
 
-impl Ninedof {
+impl NinedofDriver {
     pub fn read_acceleration(&mut self) -> TockResult<NinedofReading> {
         let res: CbData = Default::default();
         subscribe(Self::cb, unsafe { mem::transmute(&res) })?;
@@ -57,12 +58,6 @@
     }
 }
 
-impl Default for Ninedof {
-    fn default() -> Self {
-        Ninedof
-    }
-}
-
 pub fn subscribe(cb: extern "C" fn(usize, usize, usize, usize), ud: usize) -> TockResult<()> {
     syscalls::subscribe_fn(DRIVER_NUM, 0, cb, ud)?;
     Ok(())
diff --git a/src/simple_ble.rs b/src/simple_ble.rs
index 113de2d..f700385 100644
--- a/src/simple_ble.rs
+++ b/src/simple_ble.rs
@@ -10,14 +10,20 @@
 pub const BUFFER_SIZE_ADVERTISE: usize = 39;
 pub const BUFFER_SIZE_SCAN: usize = 39;
 
-mod ble_commands {
+mod command_nr {
     pub const START_ADVERTISING: usize = 0;
-    pub const ALLOW_ADVERTISMENT_BUFFER: usize = 0;
-    pub const BLE_PASSIVE_SCAN_SUB: usize = 0;
-    pub const ALLOW_SCAN_BUFFER: usize = 1;
     pub const PASSIVE_SCAN: usize = 5;
 }
 
+mod subscribe_nr {
+    pub const BLE_PASSIVE_SCAN_SUB: usize = 0;
+}
+
+mod allow_nr {
+    pub const ALLOW_ADVERTISMENT_BUFFER: usize = 0;
+    pub const ALLOW_SCAN_BUFFER: usize = 1;
+}
+
 mod gap_flags {
     pub const BLE_DISCOVERABLE: usize = 0x02;
 }
@@ -29,6 +35,7 @@
     pub const SERVICE_DATA: usize = 0x16;
 }
 
+#[non_exhaustive]
 pub struct BleAdvertisingDriver;
 
 impl BleAdvertisingDriver {
@@ -36,13 +43,14 @@
         [0; BUFFER_SIZE_ADVERTISE]
     }
     pub fn initialize<'a>(
+        &'a mut self,
         interval: usize,
         service_payload: &BlePayload,
         advertising_buffer: &'a mut [u8; BUFFER_SIZE_ADVERTISE],
     ) -> TockResult<SharedMemory<'a>> {
         let mut shared_memory = syscalls::allow(
             DRIVER_NUMBER,
-            ble_commands::ALLOW_ADVERTISMENT_BUFFER,
+            allow_nr::ALLOW_ADVERTISMENT_BUFFER,
             advertising_buffer,
         )?;
         shared_memory.write_bytes(service_payload);
@@ -53,7 +61,7 @@
     fn start_advertising(pdu_type: usize, interval: usize) -> TockResult<()> {
         syscalls::command(
             DRIVER_NUMBER,
-            ble_commands::START_ADVERTISING,
+            command_nr::START_ADVERTISING,
             pdu_type,
             interval,
         )?;
@@ -77,25 +85,31 @@
     }
 }
 
-pub struct BleDriver;
+#[non_exhaustive]
+pub struct BleScanningDriver;
 
-impl BleDriver {
+impl BleScanningDriver {
     pub fn create_scan_buffer() -> [u8; BUFFER_SIZE_SCAN] {
         [0; BUFFER_SIZE_SCAN]
     }
 
-    pub fn share_memory(scan_buffer: &mut [u8; BUFFER_SIZE_SCAN]) -> TockResult<SharedMemory> {
-        syscalls::allow(DRIVER_NUMBER, ble_commands::ALLOW_SCAN_BUFFER, scan_buffer)
-            .map_err(Into::into)
+    pub fn share_memory<'a, 'b>(
+        &'a mut self,
+        scan_buffer: &'b mut [u8; BUFFER_SIZE_SCAN],
+    ) -> TockResult<SharedMemory<'b>> {
+        syscalls::allow(DRIVER_NUMBER, allow_nr::ALLOW_SCAN_BUFFER, scan_buffer).map_err(Into::into)
     }
 
-    pub fn start<CB>(callback: &mut BleCallback<CB>) -> TockResult<CallbackSubscription>
+    pub fn start<'a, CB>(
+        &'a mut self,
+        callback: &'a mut BleCallback<CB>,
+    ) -> TockResult<CallbackSubscription>
     where
         BleCallback<CB>: SubscribableCallback,
     {
         let subscription =
-            syscalls::subscribe(DRIVER_NUMBER, ble_commands::BLE_PASSIVE_SCAN_SUB, callback)?;
-        syscalls::command(DRIVER_NUMBER, ble_commands::PASSIVE_SCAN, 1, 0)?;
+            syscalls::subscribe(DRIVER_NUMBER, subscribe_nr::BLE_PASSIVE_SCAN_SUB, callback)?;
+        syscalls::command(DRIVER_NUMBER, command_nr::PASSIVE_SCAN, 1, 0)?;
         Ok(subscription)
     }
 }
diff --git a/src/temperature.rs b/src/temperature.rs
index 28e366f..4420791 100644
--- a/src/temperature.rs
+++ b/src/temperature.rs
@@ -7,21 +7,35 @@
 use core::mem;
 
 const DRIVER_NUMBER: usize = 0x60000;
-const SUBSCRIBE_CALLBACK: usize = 0;
-const START_MEASUREMENT: usize = 1;
 
-pub async fn measure_temperature() -> Result<Temperature, TockError> {
-    let temperature = Cell::<Option<isize>>::new(None);
-    let mut callback = |arg1, _, _| temperature.set(Some(arg1 as isize));
-    let subscription = syscalls::subscribe(DRIVER_NUMBER, SUBSCRIBE_CALLBACK, &mut callback)?;
-    syscalls::command(DRIVER_NUMBER, START_MEASUREMENT, 0, 0)?;
-    let temperatur = Temperature {
-        centi_celsius: futures::wait_for_value(|| temperature.get()).await,
-    };
-    mem::drop(subscription);
-    Ok(temperatur)
+mod command_nr {
+    pub const START_MEASUREMENT: usize = 1;
 }
 
+mod subscribe_nr {
+    pub const SUBSCRIBE_CALLBACK: usize = 0;
+}
+
+#[non_exhaustive]
+pub struct TemperatureDriver;
+
+impl TemperatureDriver {
+    pub async fn measure_temperature(&mut self) -> Result<Temperature, TockError> {
+        let temperature = Cell::<Option<isize>>::new(None);
+        let mut callback = |arg1, _, _| temperature.set(Some(arg1 as isize));
+        let subscription = syscalls::subscribe(
+            DRIVER_NUMBER,
+            subscribe_nr::SUBSCRIBE_CALLBACK,
+            &mut callback,
+        )?;
+        syscalls::command(DRIVER_NUMBER, command_nr::START_MEASUREMENT, 0, 0)?;
+        let temperatur = Temperature {
+            centi_celsius: futures::wait_for_value(|| temperature.get()).await,
+        };
+        mem::drop(subscription);
+        Ok(temperatur)
+    }
+}
 #[derive(Copy, Clone)]
 pub struct Temperature {
     centi_celsius: isize,
diff --git a/src/timer.rs b/src/timer.rs
index a0172b0..80adc1a 100644
--- a/src/timer.rs
+++ b/src/timer.rs
@@ -10,6 +10,7 @@
 use crate::syscalls;
 use core::cell::Cell;
 use core::isize;
+use core::marker::PhantomData;
 use core::ops::{Add, AddAssign, Sub};
 
 const DRIVER_NUMBER: usize = 0x00000;
@@ -26,19 +27,13 @@
     pub const SUBSCRIBE_CALLBACK: usize = 0;
 }
 
-pub fn with_callback<CB>(callback: CB) -> WithCallback<CB> {
-    WithCallback {
-        callback,
-        clock_frequency: ClockFrequency { hz: 0 },
-    }
-}
-
-pub struct WithCallback<CB> {
+pub struct WithCallback<'a, CB> {
     callback: CB,
     clock_frequency: ClockFrequency,
+    phantom: PhantomData<&'a mut ()>,
 }
 
-impl<CB: FnMut(ClockValue, Alarm)> SubscribableCallback for WithCallback<CB> {
+impl<CB: FnMut(ClockValue, Alarm)> SubscribableCallback for WithCallback<'_, CB> {
     fn call_rust(&mut self, clock_value: usize, alarm_id: usize, _: usize) {
         (self.callback)(
             ClockValue {
@@ -50,11 +45,11 @@
     }
 }
 
-impl<CB> WithCallback<CB>
+impl<'a, CB> WithCallback<'a, CB>
 where
     Self: SubscribableCallback,
 {
-    pub fn init(&mut self) -> TockResult<Timer> {
+    pub fn init(&'a mut self) -> TockResult<Timer<'a>> {
         let num_notifications =
             syscalls::command(DRIVER_NUMBER, command_nr::IS_DRIVER_AVAILABLE, 0, 0)?;
 
@@ -282,10 +277,8 @@
     }
 }
 
-static mut TIMER_DRIVER_AVAILABLE: bool = true;
-
 #[derive(Copy, Clone, Default, PartialEq, Eq)]
-struct ActiveTimer {
+pub(crate) struct ActiveTimer {
     instant: u32,
     set_at: u32,
 }
@@ -295,55 +288,32 @@
 /// ```no_run
 /// # use libtock::timer::DriverContext;
 /// # use libtock::result::TockResult;
+/// # use libtock::Drivers;
 /// # #[libtock::main]
 /// # async fn main() -> TockResult<()> {
-/// let context = DriverContext::create();
+///  let Drivers {  timer_context, .. } = libtock::retrieve_drivers()?;
 /// # Ok(())
 /// # }
 /// ```
+#[non_exhaustive]
 pub struct DriverContext {
-    active_timer: Cell<Option<ActiveTimer>>,
-    current_time: Cell<usize>,
+    pub(crate) active_timer: Cell<Option<ActiveTimer>>,
 }
 
 impl DriverContext {
-    /// Create a driver context
-    pub fn create() -> TockResult<Self> {
-        let num_ticks = get_current_ticks()?;
-        Ok(DriverContext {
-            active_timer: Default::default(),
-            current_time: Cell::new(num_ticks),
-        })
-    }
-    /// Create a driver timer from a context. As the driver is a singleton
-    /// from the app perspective this function will return None
-    /// if called more than once.
-    pub fn create_timer_driver<'a>(&'a self) -> TockResult<TimerDriver<'a>> {
-        if unsafe { TIMER_DRIVER_AVAILABLE } {
-            unsafe {
-                TIMER_DRIVER_AVAILABLE = false;
-            }
-            Ok(TimerDriver {
-                callback: Callback {
-                    now: &self.current_time,
-                },
-                context: &self,
-            })
-        } else {
-            Err(TockError::Other(OtherError::DriverAlreadyTaken))
+    /// Create a driver timer from a context.
+    pub fn create_timer_driver(&self) -> TimerDriver<'_> {
+        TimerDriver {
+            callback: Callback,
+            context: &self,
         }
     }
 
-    /// Create a timer driver instance without checking for running instance
-    /// # Safety
-    /// May lead to undefined behavior at the previous consumer of the timer driver.
-    /// Only safe if no other consumer is still running (e.g. on unwind)
-    pub unsafe fn create_timer_driver_unsafe(&self) -> TimerDriver<'_> {
-        TimerDriver {
-            callback: Callback {
-                now: &self.current_time,
-            },
-            context: &self,
+    pub fn with_callback<CB>(&mut self, callback: CB) -> WithCallback<CB> {
+        WithCallback {
+            callback,
+            clock_frequency: ClockFrequency { hz: 0 },
+            phantom: PhantomData,
         }
     }
 }
@@ -352,26 +322,24 @@
 /// ```no_run
 /// # use libtock::timer::DriverContext;
 /// # use libtock::result::TockResult;
+/// # use libtock::Drivers;
 /// # #[libtock::main]
 /// # async fn main() -> TockResult<()> {
-/// let context = DriverContext::create()?;
-/// context.create_timer_driver().expect("The timer driver is a singleton and can only created once.");
+/// # let Drivers {  timer_context,.. } = libtock::retrieve_drivers()?;
+/// # let mut driver = timer_context.create_timer_driver();
+/// let timer_driver = driver.activate()?;
 /// # Ok(())
 /// # }
 /// ```
 pub struct TimerDriver<'a> {
-    callback: Callback<'a>,
+    callback: Callback,
     context: &'a DriverContext,
 }
 
-struct Callback<'a> {
-    now: &'a Cell<usize>,
-}
+struct Callback;
 
-impl<'a> SubscribableCallback for Callback<'a> {
-    fn call_rust(&mut self, now: usize, _: usize, _: usize) {
-        self.now.set(now);
-    }
+impl SubscribableCallback for Callback {
+    fn call_rust(&mut self, _: usize, _: usize, _: usize) {}
 }
 
 /// Activated time driver. Updates current time in the context and manages
@@ -381,10 +349,11 @@
 /// # use libtock::timer::DriverContext;
 /// # use libtock::result::TockResult;
 /// # use libtock::timer::Duration;
+/// # use libtock::Drivers;
 /// # #[libtock::main]
 /// # async fn main() -> TockResult<()> {
-/// let context = DriverContext::create()?;
-/// let mut driver = context.create_timer_driver().unwrap();
+/// # let Drivers {  timer_context,.. } = libtock::retrieve_drivers()?;
+/// # let mut driver = timer_context.create_timer_driver();
 /// let timer_driver = driver.activate()?;
 /// timer_driver.sleep(Duration::from_ms(1000)).await?;
 /// # Ok(())
@@ -416,7 +385,6 @@
     /// Sleep for the given duration
     pub async fn sleep(&self, duration: Duration<usize>) -> TockResult<()> {
         let now = get_current_ticks()?;
-        self.context.current_time.set(now);
         let freq = get_clock_frequency()?;
         let alarm_instant = Self::compute_alarm_instant(duration.ms, now, freq)?;
         let this_alarm = ActiveTimer {