diff --git a/.run/List All nScopes.run.xml b/.run/List All nScopes.run.xml
index 919fb97..171f82e 100644
--- a/.run/List All nScopes.run.xml	
+++ b/.run/List All nScopes.run.xml	
@@ -1,6 +1,6 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="List All nScopes" type="CargoCommandRunConfiguration" factoryName="Cargo Command" folderName="Examples">
-    <option name="command" value="run --example list_all_nscopes" />
+  <configuration default="false" name="List All nLabs" type="CargoCommandRunConfiguration" factoryName="Cargo Command" folderName="Examples">
+    <option name="command" value="run --example list_all_nlabs" />
     <option name="workingDirectory" value="file://$PROJECT_DIR$" />
     <option name="emulateTerminal" value="false" />
     <option name="channel" value="DEFAULT" />
diff --git a/Cargo.toml b/Cargo.toml
index f5fb668..24a44e6 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,14 +1,14 @@
 [package]
-name = "nscope"
+name = "nlabapi"
 version = "1.0.0"
-authors = ["David Meyer <david@nscope.org>"]
+authors = ["David Meyer <david@getnlab.com>"]
 license = "GPL-3.0"
 description = """
-Communication with nScope devices
+Communication with nLab devices
 """
-homepage = "https://www.nscope.org"
-repository = "https://github.com/nLabs-nScope/nscope-rs"
-documentation = "https://github.com/nLabs-nScope/nscope-rs"
+homepage = "https://www.getnlab.com"
+repository = "https://github.com/nLabs-nScope/nlabapi"
+documentation = "https://github.com/nLabs-nScope/nlabapi"
 readme = "README.md"
 edition = "2018"
 
diff --git a/README.md b/README.md
index d895bbc..8b2e7cd 100644
--- a/README.md
+++ b/README.md
@@ -1,8 +1,8 @@
-# nscope-rs
-[![Crates.io](https://img.shields.io/crates/v/nscope)](https://crates.io/crates/nscope)
-[![License](https://img.shields.io/crates/l/nscope)](LICENSE)
-[![Documentation](https://docs.rs/nscope/badge.svg)](https://docs.rs/nscope)
+# nlabapi
+[![Crates.io](https://img.shields.io/crates/v/nlabapi)](https://crates.io/crates/nlabapi)
+[![License](https://img.shields.io/crates/l/nlabapi)](LICENSE)
+[![Documentation](https://docs.rs/nlabapi/badge.svg)](https://docs.rs/nlabapi)
 
-![Cargo Test](https://github.com/nLabs-nScope/nscope-rs/actions/workflows/tests.yml/badge.svg)
+![Cargo Test](https://github.com/nLabs-nScope/nlabapi/actions/workflows/tests.yml/badge.svg)
 
-A Rust implementation of the nScope API.
+Low-level software interface for nLab devices
\ No newline at end of file
diff --git a/examples/analog_outputs.rs b/examples/analog_outputs.rs
index 2ef95b2..d1161f1 100644
--- a/examples/analog_outputs.rs
+++ b/examples/analog_outputs.rs
@@ -1,14 +1,14 @@
 /***************************************************************************************************
  *
  *  nLabs, LLC
- *  https://nscope.org
+ *  https://getnlab.com
  *  Copyright(c) 2020. All Rights Reserved
  *
- *  This file is part of the nScope API
+ *  This file is part of the nLab API
  *
  **************************************************************************************************/
 
-use nscope::{LabBench};
+use nlabapi::{LabBench};
 use std::{thread, time};
 use std::error::Error;
 
@@ -18,16 +18,16 @@ fn main() -> Result<(), Box<dyn Error>> {
     // Create a LabBench
     let bench = LabBench::new()?;
 
-    // Open the first available nScope
-    let nscope = bench.open_first_available(true)?;
+    // Open the first available nLab
+    let nlab = bench.open_first_available(true)?;
 
-    nscope.a1.turn_on();
+    nlab.a1.turn_on();
     thread::sleep(time::Duration::from_secs(10));
-    nscope.a1.turn_off();
+    nlab.a1.turn_off();
 
-    nscope.a2.turn_on();
+    nlab.a2.turn_on();
     thread::sleep(time::Duration::from_secs(10));
-    nscope.a2.turn_off();
+    nlab.a2.turn_off();
 
     Ok(())
 }
\ No newline at end of file
diff --git a/examples/data_request.rs b/examples/data_request.rs
index e27e0ee..2d830e0 100644
--- a/examples/data_request.rs
+++ b/examples/data_request.rs
@@ -1,14 +1,14 @@
 /***************************************************************************************************
  *
  *  nLabs, LLC
- *  https://nscope.org
+ *  https://getnlab.com
  *  Copyright(c) 2020. All Rights Reserved
  *
- *  This file is part of the nScope API
+ *  This file is part of the nLab API
  *
  **************************************************************************************************/
 
-use nscope::{AnalogSignalPolarity, LabBench, Trigger, TriggerType};
+use nlabapi::{AnalogSignalPolarity, LabBench, Trigger, TriggerType};
 use std::error::Error;
 
 fn main() -> Result<(), Box<dyn Error>> {
@@ -17,21 +17,21 @@ fn main() -> Result<(), Box<dyn Error>> {
     // Create a LabBench
     let bench = LabBench::new()?;
 
-    // Open the first available nScope
-    let nscope = bench.open_first_available(true)?;
+    // Open the first available nLab
+    let nlab = bench.open_first_available(true)?;
 
-    nscope.a1.turn_on();
+    nlab.a1.turn_on();
 
-    let sweep_handle = nscope.request(8000.0, 19200, None);
+    let sweep_handle = nlab.request(8000.0, 19200, None);
 
     for sample in sweep_handle.receiver {
         println!("{:?}", sample.data);
     }
 
-    nscope.a1.turn_off();
+    nlab.a1.turn_off();
     
     
-    let sweep_handle = nscope.request(8000.0, 19200, Some(Trigger{
+    let sweep_handle = nlab.request(8000.0, 19200, Some(Trigger{
         is_enabled: true,
         trigger_type: TriggerType::RisingEdge,
         source_channel: 0,
@@ -39,8 +39,8 @@ fn main() -> Result<(), Box<dyn Error>> {
         trigger_delay_us: 0,
     }));
 
-    nscope.a1.set_polarity(AnalogSignalPolarity::Bipolar);
-    nscope.a1.turn_on();
+    nlab.a1.set_polarity(AnalogSignalPolarity::Bipolar);
+    nlab.a1.turn_on();
     for sample in sweep_handle.receiver {
         println!("{:?}", sample.data);
     }
diff --git a/examples/fast_communication.rs b/examples/fast_communication.rs
index 0130788..5247e0e 100644
--- a/examples/fast_communication.rs
+++ b/examples/fast_communication.rs
@@ -1,14 +1,14 @@
 /***************************************************************************************************
  *
  *  nLabs, LLC
- *  https://nscope.org
+ *  https://getnlab.com
  *  Copyright(c) 2020. All Rights Reserved
  *
- *  This file is part of the nScope API
+ *  This file is part of the nLab API
  *
  **************************************************************************************************/
 
-use nscope::LabBench;
+use nlabapi::LabBench;
 use std::error::Error;
 
 fn main() -> Result<(), Box<dyn Error>> {
@@ -17,16 +17,16 @@ fn main() -> Result<(), Box<dyn Error>> {
     // Create a LabBench
     let bench = LabBench::new()?;
 
-    // Open the first available nScope
-    let mut nscope = bench.open_first_available(true)?;
+    // Open the first available nLab
+    let mut nlab = bench.open_first_available(true)?;
 
-    nscope.ch1.turn_on();
-    nscope.ch2.turn_on();
-    nscope.ch3.turn_on();
-    nscope.ch4.turn_on();
+    nlab.ch1.turn_on();
+    nlab.ch2.turn_on();
+    nlab.ch3.turn_on();
+    nlab.ch4.turn_on();
 
     loop {
-        let sweep_handle = nscope.request(2_000_000.0, 1200, None);
+        let sweep_handle = nlab.request(2_000_000.0, 1200, None);
         while sweep_handle.receiver.recv().is_ok() {}
     }
 }
\ No newline at end of file
diff --git a/examples/list_all_nscopes.rs b/examples/list_all_nscopes.rs
index bd7a456..8ff2201 100644
--- a/examples/list_all_nscopes.rs
+++ b/examples/list_all_nscopes.rs
@@ -1,14 +1,14 @@
 /***************************************************************************************************
  *
  *  nLabs, LLC
- *  https://nscope.org
+ *  https://getnlab.com
  *  Copyright(c) 2020. All Rights Reserved
  *
- *  This file is part of the nScope API
+ *  This file is part of the nLab API
  *
  **************************************************************************************************/
 
-use nscope::LabBench;
+use nlabapi::LabBench;
 use std::error::Error;
 
 fn main() -> Result<(), Box<dyn Error>> {
@@ -17,13 +17,13 @@ fn main() -> Result<(), Box<dyn Error>> {
     // Create a LabBench
     let bench = LabBench::new()?;
 
-    // Print the bench to show a list of detected nScopes
+    // Print the bench to show a list of detected nLabs
     println!("Lab Bench: \n{:?}", bench);
 
-    println!("\nManual list of all detected nScopes:");
-    // Or loop over all nScope links in the list and print them
-    for nscope_link in bench.list() {
-        println!("    {:?}", nscope_link)
+    println!("\nManual list of all detected nLabs:");
+    // Or loop over all nLab links in the list and print them
+    for nlab_link in bench.list() {
+        println!("    {:?}", nlab_link)
     }
     Ok(())
 }
diff --git a/examples/monitor_power.rs b/examples/monitor_power.rs
index d930cde..02b3306 100644
--- a/examples/monitor_power.rs
+++ b/examples/monitor_power.rs
@@ -1,14 +1,14 @@
 /***************************************************************************************************
  *
  *  nLabs, LLC
- *  https://nscope.org
+ *  https://getnlab.com
  *  Copyright(c) 2020. All Rights Reserved
  *
- *  This file is part of the nScope API
+ *  This file is part of the nLab API
  *
  **************************************************************************************************/
 
-use nscope::{LabBench, Nscope};
+use nlabapi::{LabBench, Nlab};
 use std::{thread, time};
 use std::error::Error;
 
@@ -18,15 +18,15 @@ fn main() -> Result<(), Box<dyn Error>> {
     // Create a LabBench
     let bench = LabBench::new()?;
 
-    // Open all available nScope links
-    let mut nscopes: Vec<Nscope> = bench.open_all_available();
+    // Open all available nLab links
+    let mut nlabs: Vec<Nlab> = bench.open_all_available();
 
     loop {
         thread::sleep(time::Duration::from_millis(10));
 
-        nscopes.retain(|n| n.is_connected());
+        nlabs.retain(|n| n.is_connected());
 
-        for n in nscopes.iter() {
+        for n in nlabs.iter() {
             match n.power_status() {
                 Ok(status) => {
                     let state = format!("{:?}", status.state);
@@ -36,8 +36,8 @@ fn main() -> Result<(), Box<dyn Error>> {
             }
         }
 
-        if nscopes.is_empty() {
-            return Err("Cannot find any nScopes".into())
+        if nlabs.is_empty() {
+            return Err("Cannot find any nLabs".into())
         }
     }
 }
diff --git a/examples/pulse_outputs.rs b/examples/pulse_outputs.rs
index 327b4bc..dc2838d 100644
--- a/examples/pulse_outputs.rs
+++ b/examples/pulse_outputs.rs
@@ -1,14 +1,14 @@
 /***************************************************************************************************
  *
  *  nLabs, LLC
- *  https://nscope.org
+ *  https://getnlab.com
  *  Copyright(c) 2020. All Rights Reserved
  *
- *  This file is part of the nScope API
+ *  This file is part of the nLab API
  *
  **************************************************************************************************/
 
-use nscope::{LabBench};
+use nlabapi::{LabBench};
 use std::{thread, time};
 use std::error::Error;
 
@@ -18,16 +18,16 @@ fn main() -> Result<(), Box<dyn Error>> {
     // Create a LabBench
     let bench = LabBench::new()?;
 
-    // Open the first available nScope
-    let nscope = bench.open_first_available(true)?;
+    // Open the first available nLab
+    let nlab = bench.open_first_available(true)?;
 
-    nscope.p1.turn_on();
+    nlab.p1.turn_on();
     thread::sleep(time::Duration::from_secs(10));
-    nscope.p1.turn_off();
+    nlab.p1.turn_off();
 
-    nscope.p2.turn_on();
+    nlab.p2.turn_on();
     thread::sleep(time::Duration::from_secs(10));
-    nscope.p2.turn_off();
+    nlab.p2.turn_off();
 
     Ok(())
 }
\ No newline at end of file
diff --git a/examples/update_firmware.rs b/examples/update_firmware.rs
index 46e3d87..9e6961a 100644
--- a/examples/update_firmware.rs
+++ b/examples/update_firmware.rs
@@ -1,14 +1,14 @@
 /***************************************************************************************************
  *
  *  nLabs, LLC
- *  https://nscope.org
+ *  https://getnlab.com
  *  Copyright(c) 2020. All Rights Reserved
  *
- *  This file is part of the nScope API
+ *  This file is part of the nLab API
  *
  **************************************************************************************************/
 
-use nscope::LabBench;
+use nlabapi::LabBench;
 use std::error::Error;
 use std::thread;
 use std::time::Duration;
@@ -19,14 +19,14 @@ fn main() -> Result<(), Box<dyn Error>> {
     // Create a LabBench
     let mut bench = LabBench::new()?;
 
-    // Print the bench to show a list of detected nScopes
+    // Print the bench to show a list of detected nLabs
     println!("{:?}", bench);
 
-    for nscope_link in bench.list() {
-        // Request DFU on any nScope that is available
-        if nscope_link.available {
-            if let Err(e) = nscope_link.request_dfu() {
-                println!("Failed to request DFU on an available nScope: {e}")
+    for nlab_link in bench.list() {
+        // Request DFU on any nLab that is available
+        if nlab_link.available {
+            if let Err(e) = nlab_link.request_dfu() {
+                println!("Failed to request DFU on an available nLab: {e}")
             }
         }
     }
@@ -38,9 +38,9 @@ fn main() -> Result<(), Box<dyn Error>> {
     // Print the bench to show the refreshed list
     println!("{:?}", bench);
 
-    for nscope_link in bench.list() {
-        if let Err(e) = nscope_link.update() {
-            println!("Encountered an error updating nScope: {e}")
+    for nlab_link in bench.list() {
+        if let Err(e) = nlab_link.update() {
+            println!("Encountered an error updating nLab: {e}")
         }
     }
 
diff --git a/src/firmware.rs b/src/firmware.rs
index d115f41..278ac97 100644
--- a/src/firmware.rs
+++ b/src/firmware.rs
@@ -1,10 +1,10 @@
 /***************************************************************************************************
  *
  *  nLabs, LLC
- *  https://nscope.org
+ *  https://getnlab.com
  *  Copyright(c) 2020. All Rights Reserved
  *
- *  This file is part of the nScope API
+ *  This file is part of the nLab API
  *
  **************************************************************************************************/
 
diff --git a/src/lab_bench.rs b/src/lab_bench.rs
index ef0f06a..075575e 100644
--- a/src/lab_bench.rs
+++ b/src/lab_bench.rs
@@ -1,14 +1,14 @@
 /***************************************************************************************************
  *
  *  nLabs, LLC
- *  https://nscope.org
+ *  https://getnlab.com
  *  Copyright(c) 2020. All Rights Reserved
  *
- *  This file is part of the nScope API
+ *  This file is part of the nLab API
  *
  **************************************************************************************************/
 
-use crate::scope::Nscope;
+use crate::scope::Nlab;
 use std::{fmt, io};
 use std::error::Error;
 use std::sync::{Arc, RwLock};
@@ -18,7 +18,7 @@ use crate::firmware::{FIRMWARE, FIRMWARE_VERSION};
 #[derive(Clone)]
 pub(crate) struct HidDevice(hidapi::DeviceInfo);
 
-pub(crate) enum NscopeDevice {
+pub(crate) enum NlabDevice {
     HidApiDevice { device: HidDevice, api: Arc<RwLock<hidapi::HidApi>> },
     RusbDevice(rusb::Device<rusb::GlobalContext>),
 }
@@ -45,24 +45,24 @@ impl HidDevice {
 }
 
 
-/// A representation of all the nScopes plugged into a computer
+/// A representation of all the nLabs plugged into a computer
 pub struct LabBench {
     hid_api: Arc<RwLock<hidapi::HidApi>>,
     hid_devices: Vec<HidDevice>,
     rusb_devices: Vec<rusb::Device<rusb::GlobalContext>>,
 }
 
-/// A detected link between the computer and an nScope, used to open and retrieve an nScope
-pub struct NscopeLink {
+/// A detected link between the computer and an nLab, used to open and retrieve an nLab
+pub struct NlabLink {
     pub available: bool,
     pub in_dfu: bool,
     pub needs_update: bool,
-    device: NscopeDevice,
+    device: NlabDevice,
 }
 
 
 impl LabBench {
-    /// Creates a new lab bench, searching the computer for nScope links
+    /// Creates a new lab bench, searching the computer for nLab links
     pub fn new() -> Result<LabBench, Box<dyn Error>> {
         let hid_api = hidapi::HidApi::new()?;
         Ok(LabBench {
@@ -72,7 +72,7 @@ impl LabBench {
         })
     }
 
-    /// Refreshes the list of nScope Links
+    /// Refreshes the list of nLab Links
     pub fn refresh(&mut self) {
         let mut api = self.hid_api.write().unwrap();
         api.refresh_devices().expect("failed to refresh");
@@ -80,51 +80,51 @@ impl LabBench {
         self.rusb_devices = rusb::devices().unwrap().iter().collect();
     }
 
-    /// Returns iterator containing information about detected nScopes plugged into the computer
-    pub fn list(&self) -> impl Iterator<Item=NscopeLink> + '_ {
-        let v1_nscopes = self.hid_devices
+    /// Returns iterator containing information about detected nLabs plugged into the computer
+    pub fn list(&self) -> impl Iterator<Item=NlabLink> + '_ {
+        let v1_nlabs = self.hid_devices
             .iter()
-            .filter_map(move |d| NscopeLink::new(
-                NscopeDevice::HidApiDevice {
+            .filter_map(move |d| NlabLink::new(
+                NlabDevice::HidApiDevice {
                     device: d.clone(),
                     api: Arc::clone(&self.hid_api),
                 }
             ));
 
-        let v2_nscopes = self.rusb_devices
+        let v2_nlabs = self.rusb_devices
             .iter()
-            .filter_map(move |d| NscopeLink::new(
-                NscopeDevice::RusbDevice(d.clone())
+            .filter_map(move |d| NlabLink::new(
+                NlabDevice::RusbDevice(d.clone())
             ));
 
-        v2_nscopes.chain(v1_nscopes)
+        v2_nlabs.chain(v1_nlabs)
     }
 
-    /// Returns a vector containing all nScopes that are available
-    pub fn open_all_available(&self) -> Vec<Nscope> {
+    /// Returns a vector containing all nLabs that are available
+    pub fn open_all_available(&self) -> Vec<Nlab> {
         self.list().filter_map(|nsl| nsl.open(false).ok()).collect()
     }
 
-    /// Returns the first available nScope
-    pub fn open_first_available(&self, power_on: bool) -> Result<Nscope, io::Error> {
+    /// Returns the first available nLab
+    pub fn open_first_available(&self, power_on: bool) -> Result<Nlab, io::Error> {
 
-        // Default error is that we found zero nScopes
-        let mut err = io::Error::new(io::ErrorKind::NotFound, "Cannot find any nScopes");
+        // Default error is that we found zero nLabs
+        let mut err = io::Error::new(io::ErrorKind::NotFound, "Cannot find any nLabs");
 
 
         for nsl in self.list() {
-            if let Ok(nscope) = nsl.open(power_on) {
-                // return the first open nScope
-                return Ok(nscope);
+            if let Ok(nlab) = nsl.open(power_on) {
+                // return the first open nLab
+                return Ok(nlab);
             }
-            // If we've gotten here, then the error is that we cannot open an nScope
-            err = io::Error::new(io::ErrorKind::ConnectionRefused, "Cannot connect to any nScopes");
+            // If we've gotten here, then the error is that we cannot open an nLab
+            err = io::Error::new(io::ErrorKind::ConnectionRefused, "Cannot connect to any nLabs");
         }
         Err(err)
     }
 
-    /// Returns the first nScope that is in DFU mode
-    pub fn get_first_in_dfu(&self) -> Option<NscopeLink> {
+    /// Returns the first nLab that is in DFU mode
+    pub fn get_first_in_dfu(&self) -> Option<NlabLink> {
         for nsl in self.list() {
             if nsl.in_dfu {
                 return Some(nsl)
@@ -133,8 +133,8 @@ impl LabBench {
         None
     }
 
-    /// Returns the first nScope that is available and needs an update
-    pub fn get_first_needing_update(&self) -> Option<NscopeLink> {
+    /// Returns the first nLab that is available and needs an update
+    pub fn get_first_needing_update(&self) -> Option<NlabLink> {
         for nsl in self.list() {
             if nsl.needs_update && nsl.available {
                 return Some(nsl)
@@ -144,11 +144,11 @@ impl LabBench {
     }
 }
 
-impl NscopeLink {
-    fn new(device: NscopeDevice) -> Option<Self> {
+impl NlabLink {
+    fn new(device: NlabDevice) -> Option<Self> {
         match device {
-            NscopeDevice::HidApiDevice { device: info, api } => { NscopeLink::from_hid_device(info, api) }
-            NscopeDevice::RusbDevice(device) => { NscopeLink::from_rusb_device(device) }
+            NlabDevice::HidApiDevice { device: info, api } => { NlabLink::from_hid_device(info, api) }
+            NlabDevice::RusbDevice(device) => { NlabLink::from_rusb_device(device) }
         }
     }
 
@@ -156,11 +156,11 @@ impl NscopeLink {
         if info.vendor_id() == 0x04D8 && info.product_id() == 0xF3F6 {
             let hid_api = api.read().ok()?;
             let available = info.open_device(&hid_api).is_ok();
-            return Some(NscopeLink {
+            return Some(NlabLink {
                 available,
                 in_dfu: false,
                 needs_update: false,
-                device: NscopeDevice::HidApiDevice { device: info.clone(), api: Arc::clone(&api) },
+                device: NlabDevice::HidApiDevice { device: info.clone(), api: Arc::clone(&api) },
             });
         }
         None
@@ -179,18 +179,18 @@ impl NscopeLink {
                         available = true;
                     }
                 }
-                return Some(NscopeLink {
+                return Some(NlabLink {
                     available,
                     in_dfu: false,
                     needs_update: firmware_version != rusb::Version::from_bcd(FIRMWARE_VERSION),
-                    device: NscopeDevice::RusbDevice(device),
+                    device: NlabDevice::RusbDevice(device),
                 });
             } else if device_desc.vendor_id() == 0x0483 && device_desc.product_id() == 0xA4AB {
-                return Some(NscopeLink {
+                return Some(NlabLink {
                     available: false,
                     in_dfu: true,
                     needs_update: false,
-                    device: NscopeDevice::RusbDevice(device),
+                    device: NlabDevice::RusbDevice(device),
                 });
             }
         }
@@ -199,13 +199,13 @@ impl NscopeLink {
 
 
     ///
-    /// Takes an NscopeLink and checks to ensure the device is still connected.
+    /// Takes an NlabLink and checks to ensure the device is still connected.
     ///
-    /// Returns a validated NscopeLink if the device is still connected, otherwise returns None
+    /// Returns a validated NlabLink if the device is still connected, otherwise returns None
     ///
     pub fn validate(self) -> Option<Self> {
         match self.device {
-            NscopeDevice::HidApiDevice { device: info, api } => {
+            NlabDevice::HidApiDevice { device: info, api } => {
                 let detected_devices: Option<Vec<HidDevice>> = match api.write() {
                     Ok(mut hid_api) => {
                         if hid_api.refresh_devices().is_ok() {
@@ -220,17 +220,17 @@ impl NscopeLink {
                 if let Some(device_list) = detected_devices {
                     for device in device_list {
                         if device == info {
-                            return NscopeLink::from_hid_device(device, api);
+                            return NlabLink::from_hid_device(device, api);
                         }
                     }
                 }
                 None
             }
-            NscopeDevice::RusbDevice(existing_device) => {
+            NlabDevice::RusbDevice(existing_device) => {
                 if let Ok(devices) = rusb::devices() {
                     for detected_device in devices.iter() {
                         if existing_device == detected_device {
-                            return NscopeLink::from_rusb_device(detected_device);
+                            return NlabLink::from_rusb_device(detected_device);
                         }
                     }
                 }
@@ -240,32 +240,32 @@ impl NscopeLink {
     }
 
 
-    /// Opens and returns the nScope at the link
+    /// Opens and returns the nLab at the link
     ///
-    /// Fails if the nScope is in DFU mode or needs an update
-    pub fn open(&self, power_on: bool) -> Result<Nscope, Box<dyn Error>> {
+    /// Fails if the nLab is in DFU mode or needs an update
+    pub fn open(&self, power_on: bool) -> Result<Nlab, Box<dyn Error>> {
         if self.in_dfu {
-            return Err("nScope is in DFU mode".into());
+            return Err("nLab is in DFU mode".into());
         }
         if self.needs_update {
-            return Err("nScope needs a firmware update".into());
+            return Err("nLab needs a firmware update".into());
         }
-        Nscope::new(&self.device, power_on)
+        Nlab::new(&self.device, power_on)
     }
 
-    /// Update the nScope at the link
+    /// Update the nLab at the link
     ///
-    /// Fails if the nScope is not in DFU mode
+    /// Fails if the nLab is not in DFU mode
     pub fn update(&self) -> Result<(), Box<dyn Error>> {
         if !self.in_dfu {
-            return Err("nScope is not in DFU mode".into());
+            return Err("nLab is not in DFU mode".into());
         }
 
         match &self.device {
-            NscopeDevice::HidApiDevice { .. } => {
-                return Err("Cannot update nScope v1".into());
+            NlabDevice::HidApiDevice { .. } => {
+                return Err("Cannot update nLab v1".into());
             }
-            NscopeDevice::RusbDevice(device) => {
+            NlabDevice::RusbDevice(device) => {
                 let mut dfu = dfu_libusb::DfuLibusb::from_usb_device(
                     device.clone(),
                     device.open()?,
@@ -277,18 +277,18 @@ impl NscopeLink {
         Ok(())
     }
 
-    /// Requests the nScope to jump to DFU mode
+    /// Requests the nLab to jump to DFU mode
     ///
-    /// Fails if the nScope is in DFU mode or is unavailable
+    /// Fails if the nLab is in DFU mode or is unavailable
     pub fn request_dfu(&self) -> Result<(), Box<dyn Error>> {
         if self.in_dfu {
-            return Err("nScope is already in DFU mode".into());
+            return Err("nLab is already in DFU mode".into());
         }
         match &self.device {
-            NscopeDevice::HidApiDevice { .. } => {
-                return Err("Unsupported for nScope v1".into());
+            NlabDevice::HidApiDevice { .. } => {
+                return Err("Unsupported for nLab v1".into());
             }
-            NscopeDevice::RusbDevice(device) => {
+            NlabDevice::RusbDevice(device) => {
                 let out_buffer = [0u8, 6u8];
                 let device_handle = device.open()?;
                 device_handle.claim_interface(0)?;
@@ -301,15 +301,15 @@ impl NscopeLink {
 
 impl fmt::Debug for LabBench {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{:#?}", self.list().collect::<Vec<NscopeLink>>())
+        write!(f, "{:#?}", self.list().collect::<Vec<NlabLink>>())
     }
 }
 
-impl fmt::Debug for NscopeLink {
+impl fmt::Debug for NlabLink {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let device_name = match &self.device {
-            NscopeDevice::HidApiDevice { .. } => { "nScope v1" }
-            NscopeDevice::RusbDevice(_) => { "nScope v2" }
+            NlabDevice::HidApiDevice { .. } => { "nLab v1" }
+            NlabDevice::RusbDevice(_) => { "nLab v2" }
         };
         if self.in_dfu {
             write!(
diff --git a/src/lib.rs b/src/lib.rs
index 8a41436..22ff8cf 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,42 +1,42 @@
 /***************************************************************************************************
  *
  *  nLabs, LLC
- *  https://nscope.org
+ *  https://getnlab.com
  *  Copyright(c) 2020. All Rights Reserved
  *
- *  This file is part of the nScope API
+ *  This file is part of the nLab API
  *
  **************************************************************************************************/
 
-//! This crate provides an interface to the [nScope](https://nscope.org)
+//! This crate provides an interface to the [nLab](https://getnlab.com)
 //!
 //! # Usage
 //!
-//! This crate is [on crates.io](https://crates.io/crates/nscope) and can be
-//! used by adding `nscope` to the dependencies in your project's `Cargo.toml`.
+//! This crate is [on crates.io](https://crates.io/crates/nlabapi) and can be
+//! used by adding `nlab` to the dependencies in your project's `Cargo.toml`.
 //!
 //!
 //! # Example
 //!
 //! ```rust,no_run
-//! extern crate nscope;
-//! use nscope::LabBench;
+//! extern crate nlabapi;
+//! use nlabapi::LabBench;
 //!
 //! fn main() {
 //!     // Create a LabBench
 //!     let bench = LabBench::new().expect("Cannot create LabBench");
 //!
-//!     // Print the bench to show a list of detected nScopes
+//!     // Print the bench to show a list of detected nLabs
 //!     println!("{:?}", bench);
 //!
-//!     // Open an nScope
-//!     let nscope = bench.open_first_available(true).expect("Cannot open nScope");
+//!     // Open an nLab
+//!     let nlab = bench.open_first_available(true).expect("Cannot open nLab");
 //!
 //!     // Turn on analog output channel A1
-//!     nscope.a1.turn_on();
+//!     nlab.a1.turn_on();
 //!
 //!     // Trigger an auto-triggered sweep of 20 samples at 4.0 Hz sample rate
-//!     let sweep_handle = nscope.request(4.0, 20, None);
+//!     let sweep_handle = nlab.request(4.0, 20, None);
 //!
 //!     // Loop through the received data, blocking on each sample until it arrives
 //!     for sample in sweep_handle.receiver {
@@ -45,7 +45,7 @@
 //!     }
 //!
 //!     // Turn off the analog output channel A1
-//!     nscope.a1.turn_off();
+//!     nlab.a1.turn_off();
 //!
 //! }
 //! ```
@@ -57,8 +57,8 @@ mod version;
 mod firmware;
 
 pub use lab_bench::LabBench;
-pub use lab_bench::NscopeLink;
-pub use scope::Nscope;
+pub use lab_bench::NlabLink;
+pub use scope::Nlab;
 pub use scope::power::*;
 pub use scope::pulse_output::*;
 pub use scope::analog_output::*;
diff --git a/src/scope.rs b/src/scope.rs
index 5b02449..0747c61 100644
--- a/src/scope.rs
+++ b/src/scope.rs
@@ -1,10 +1,10 @@
 /***************************************************************************************************
  *
  *  nLabs, LLC
- *  https://nscope.org
+ *  https://getnlab.com
  *  Copyright(c) 2020. All Rights Reserved
  *
- *  This file is part of the nScope API
+ *  This file is part of the nLab API
  *
  **************************************************************************************************/
 
@@ -25,7 +25,7 @@ use commands::Command;
 use power::PowerStatus;
 use pulse_output::PulseOutput;
 use trigger::Trigger;
-use crate::lab_bench::NscopeDevice;
+use crate::lab_bench::NlabDevice;
 
 mod commands;
 pub mod analog_input;
@@ -36,14 +36,14 @@ pub mod power;
 pub mod data_requests;
 mod run_loops;
 
-enum NscopeHandle {
-    NscopeLegacy(HidDevice),
-    Nscope(rusb::DeviceHandle<rusb::GlobalContext>),
+enum NlabHandle {
+    NlabLegacy(HidDevice),
+    Nlab(rusb::DeviceHandle<rusb::GlobalContext>),
 }
 
-/// Primary interface to the nScope, used to set outputs,
+/// Primary interface to the nLab, used to set outputs,
 /// trigger sweeps of input data on scope channels, and monitor power state
-pub struct Nscope {
+pub struct Nlab {
     pub a1: AnalogOutput,
     pub a2: AnalogOutput,
     pub p1: PulseOutput,
@@ -60,22 +60,22 @@ pub struct Nscope {
     join_handle: Option<JoinHandle<()>>,
 }
 
-impl fmt::Debug for Nscope {
+impl fmt::Debug for Nlab {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "nScope v1 [ connected: {} ]", self.is_connected())
+        write!(f, "nLab v1 [ connected: {} ]", self.is_connected())
     }
 }
 
-impl Nscope {
-    /// Create a new Nscope object
-    pub(crate) fn new(dev: &NscopeDevice, power_on: bool) -> Result<Self, Box<dyn Error>> {
-        let device_handle: NscopeHandle = match dev {
-            NscopeDevice::HidApiDevice { device, api } => {
+impl Nlab {
+    /// Create a new Nlab object
+    pub(crate) fn new(dev: &NlabDevice, power_on: bool) -> Result<Self, Box<dyn Error>> {
+        let device_handle: NlabHandle = match dev {
+            NlabDevice::HidApiDevice { device, api } => {
                 let api = api.read().unwrap();
-                NscopeHandle::NscopeLegacy(device.open_device(&api)?)
+                NlabHandle::NlabLegacy(device.open_device(&api)?)
             }
-            NscopeDevice::RusbDevice(device) => {
-                NscopeHandle::Nscope(device.open()?)
+            NlabDevice::RusbDevice(device) => {
+                NlabHandle::Nlab(device.open()?)
             }
         };
 
@@ -94,21 +94,21 @@ impl Nscope {
 
         let mut is_legacy = false;
         let join_handle = match device_handle {
-            NscopeHandle::NscopeLegacy(hid_device) => {
+            NlabHandle::NlabLegacy(hid_device) => {
                 is_legacy = true;
                 communication_thread.spawn(move || {
-                    Nscope::run_v1(hid_device, backend_command_tx, command_rx, backend_fw_version, backend_power_status);
+                    Nlab::run_v1(hid_device, backend_command_tx, command_rx, backend_fw_version, backend_power_status);
                 }).ok()
             }
-            NscopeHandle::Nscope(usb_device) => {
+            NlabHandle::Nlab(usb_device) => {
                 usb_device.claim_interface(0)?;
                 communication_thread.spawn(move || {
-                    Nscope::run_v2(usb_device, backend_command_tx, command_rx, backend_fw_version, backend_power_status);
+                    Nlab::run_v2(usb_device, backend_command_tx, command_rx, backend_fw_version, backend_power_status);
                 }).ok()
             }
         };
 
-        let scope = Nscope {
+        let scope = Nlab {
             a1: AnalogOutput::create(command_tx.clone(), 0),
             a2: AnalogOutput::create(command_tx.clone(), 1),
             p1: PulseOutput::create(command_tx.clone(), 0),
@@ -127,12 +127,12 @@ impl Nscope {
         let (init_tx, init_rx) = mpsc::channel::<()>();
         if scope.command_tx.send(Command::Initialize(power_on, init_tx)).is_ok() {
             if is_legacy {
-                info!("Connected to nScope legacy firmware v{}", scope.version().unwrap() as f64 / 10.0);
+                info!("Connected to nLab legacy firmware v{}", scope.version().unwrap() as f64 / 10.0);
                 return Ok(scope);
             }
             // Wait for the response from the backend
             if init_rx.recv_timeout(Duration::from_secs(5)).is_ok() {
-                info!("Connected to nScope firmware 0x{:04X}", scope.version().unwrap());
+                info!("Connected to nLab firmware 0x{:04X}", scope.version().unwrap());
                 return Ok(scope);
             }
         }
@@ -158,15 +158,15 @@ impl Nscope {
     pub fn fw_version(&self) -> Result<u8, Box<dyn Error>> {
         if let Some(full_version) = *self.fw_version.read().unwrap() {
             if (full_version & 0xFF00) != 0 {
-                return Err("Connected to nScope v2 or newer, use scope.version() to read".into());
+                return Err("Connected to nLab v2 or newer, use scope.version() to read".into());
             }
             return Ok(full_version as u8);
         }
-        Err("Cannot read nScope version".into())
+        Err("Cannot read nLab version".into())
     }
 
     pub fn version(&self) -> Result<u16, Box<dyn Error>> {
-        self.fw_version.read().unwrap().ok_or_else(|| "Cannot read nScope version".into())
+        self.fw_version.read().unwrap().ok_or_else(|| "Cannot read nLab version".into())
     }
 
     pub fn analog_output(&self, channel: usize) -> Option<&AnalogOutput> {
@@ -196,8 +196,8 @@ impl Nscope {
     }
 }
 
-/// When an Nscope goes out of scope, we need to exit the IO loop
-impl Drop for Nscope {
+/// When an Nlab goes out of scope, we need to exit the IO loop
+impl Drop for Nlab {
     fn drop(&mut self) {
         // Send a quit command to the IO loop
         let _ = self.command_tx.send(Command::Quit);
diff --git a/src/scope/analog_input.rs b/src/scope/analog_input.rs
index 270cfab..999dd31 100644
--- a/src/scope/analog_input.rs
+++ b/src/scope/analog_input.rs
@@ -1,10 +1,10 @@
 /***************************************************************************************************
  *
  *  nLabs, LLC
- *  https://nscope.org
+ *  https://getnlab.com
  *  Copyright(c) 2020. All Rights Reserved
  *
- *  This file is part of the nScope API
+ *  This file is part of the nLab API
  *
  **************************************************************************************************/
 
diff --git a/src/scope/analog_output.rs b/src/scope/analog_output.rs
index 472f014..87a35b9 100644
--- a/src/scope/analog_output.rs
+++ b/src/scope/analog_output.rs
@@ -1,10 +1,10 @@
 /***************************************************************************************************
  *
  *  nLabs, LLC
- *  https://nscope.org
+ *  https://getnlab.com
  *  Copyright(c) 2020. All Rights Reserved
  *
- *  This file is part of the nScope API
+ *  This file is part of the nLab API
  *
  **************************************************************************************************/
 
diff --git a/src/scope/commands.rs b/src/scope/commands.rs
index 77e902e..1bc04b4 100644
--- a/src/scope/commands.rs
+++ b/src/scope/commands.rs
@@ -1,10 +1,10 @@
 /***************************************************************************************************
  *
  *  nLabs, LLC
- *  https://nscope.org
+ *  https://getnlab.com
  *  Copyright(c) 2020. All Rights Reserved
  *
- *  This file is part of the nScope API
+ *  This file is part of the nLab API
  *
  **************************************************************************************************/
 
diff --git a/src/scope/data_requests.rs b/src/scope/data_requests.rs
index 0dee87b..db5b970 100644
--- a/src/scope/data_requests.rs
+++ b/src/scope/data_requests.rs
@@ -1,10 +1,10 @@
 /***************************************************************************************************
  *
  *  nLabs, LLC
- *  https://nscope.org
+ *  https://getnlab.com
  *  Copyright(c) 2020. All Rights Reserved
  *
- *  This file is part of the nScope API
+ *  This file is part of the nLab API
  *
  **************************************************************************************************/
 
@@ -18,7 +18,7 @@ use log::{trace, debug};
 use super::AnalogInput;
 use super::Command;
 use super::commands::ScopeCommand;
-use super::Nscope;
+use super::Nlab;
 use super::Trigger;
 
 /// Voltage information from all open channels at a given time
@@ -48,7 +48,7 @@ pub(crate) struct DataRequest {
     data_collator: Arc<RwLock<[VecDeque<u16>; 4]>>,
 }
 
-/// Handle to an ongoing data sweep, holds received data from nScope
+/// Handle to an ongoing data sweep, holds received data from nLab
 #[derive(Debug)]
 pub struct SweepHandle {
     pub receiver: Receiver<Sample>,
@@ -56,7 +56,7 @@ pub struct SweepHandle {
     stop_send: Sender<()>,
 }
 
-impl Nscope {
+impl Nlab {
     pub fn request(&self, sample_rate_hz: f64, number_of_samples: u32, trigger: Option<Trigger>) -> SweepHandle {
         let (tx, rx) = mpsc::channel::<Sample>();
         let (stop_send, stop_recv) = mpsc::channel::<()>();
diff --git a/src/scope/power.rs b/src/scope/power.rs
index 56e6b52..3fcafe6 100644
--- a/src/scope/power.rs
+++ b/src/scope/power.rs
@@ -1,17 +1,17 @@
 /***************************************************************************************************
  *
  *  nLabs, LLC
- *  https://nscope.org
+ *  https://getnlab.com
  *  Copyright(c) 2020. All Rights Reserved
  *
- *  This file is part of the nScope API
+ *  This file is part of the nLab API
  *
  **************************************************************************************************/
 
 use std::io;
-use super::Nscope;
+use super::Nlab;
 
-/// Information about the power supply status of nScope
+/// Information about the power supply status of nLab
 #[derive(Debug, Copy, Clone)]
 pub struct PowerStatus {
     pub state: PowerState,
@@ -27,7 +27,7 @@ impl Default for PowerStatus {
     }
 }
 
-/// Possible states of the nScope power supply
+/// Possible states of the nLab power supply
 #[derive(Debug, PartialEq, Copy, Clone)]
 pub enum PowerState {
     PowerOff,
@@ -51,12 +51,12 @@ impl From<u8> for PowerState {
     }
 }
 
-impl Nscope {
+impl Nlab {
     pub fn power_status(&self) -> Result<PowerStatus, io::Error> {
         if !self.is_connected() {
             return Err(io::Error::new(
                 io::ErrorKind::ConnectionAborted,
-                "nScope connection aborted",
+                "nLab connection aborted",
             ));
         }
         Ok(*self.power_status.read().unwrap())
diff --git a/src/scope/pulse_output.rs b/src/scope/pulse_output.rs
index 66e8733..7ec2b47 100644
--- a/src/scope/pulse_output.rs
+++ b/src/scope/pulse_output.rs
@@ -1,10 +1,10 @@
 /***************************************************************************************************
  *
  *  nLabs, LLC
- *  https://nscope.org
+ *  https://getnlab.com
  *  Copyright(c) 2020. All Rights Reserved
  *
- *  This file is part of the nScope API
+ *  This file is part of the nLab API
  *
  **************************************************************************************************/
 
diff --git a/src/scope/run_loops/v1.rs b/src/scope/run_loops/v1.rs
index 6e64664..a9d12de 100644
--- a/src/scope/run_loops/v1.rs
+++ b/src/scope/run_loops/v1.rs
@@ -8,7 +8,7 @@ use crate::scope::{commands, StatusResponseLegacy};
 use crate::scope::commands::Command;
 
 
-impl crate::Nscope {
+impl crate::Nlab {
     pub(crate) fn run_v1(
         hid_device: HidDevice,
         command_tx: Sender<Command>,
@@ -65,7 +65,7 @@ impl crate::Nscope {
                     outgoing_usb_buffer[2] = request_id;
                 }
                 if hid_device.write(&outgoing_usb_buffer).is_err() {
-                    eprintln!("USB write error, ending nScope connection");
+                    eprintln!("USB write error, ending nLab connection");
                     break 'communication;
                 }
 
@@ -75,13 +75,13 @@ impl crate::Nscope {
                 active_requests_map.insert(request_id, command);
                 trace!("Sent request {}", request_id);
             } else if hid_device.write(&commands::NULL_REQ).is_err() {
-                eprintln!("USB write error, ending nScope connection");
+                eprintln!("USB write error, ending nLab connection");
                 break 'communication;
             }
 
             // Read the incoming command and process it
             if hid_device.read(&mut incoming_usb_buffer).is_err() {
-                eprintln!("USB read error, ending nScope connection");
+                eprintln!("USB read error, ending nLab connection");
                 break 'communication;
             }
 
diff --git a/src/scope/run_loops/v2.rs b/src/scope/run_loops/v2.rs
index a428b78..0873243 100644
--- a/src/scope/run_loops/v2.rs
+++ b/src/scope/run_loops/v2.rs
@@ -7,7 +7,7 @@ use crate::PowerStatus;
 use crate::scope::commands::{Command, ScopeCommand};
 use crate::scope::StatusResponse;
 
-impl crate::Nscope {
+impl crate::Nlab {
     pub(crate) fn run_v2(
         usb_device: DeviceHandle<rusb::GlobalContext>,
         command_tx: Sender<Command>,
@@ -98,7 +98,7 @@ impl crate::Nscope {
                     power_status.write().unwrap().usage = response.power_usage as f64 / 1000.0 * 5.0;
 
                     if response.request_id == 0 {
-                        trace!("Received a status update from nScope");
+                        trace!("Received a status update from nLab");
                     } else if let Some((id, command)) = &active_comms_request {
                         // If we have an active request with this ID
                         if *id == response.request_id {
diff --git a/src/scope/trigger.rs b/src/scope/trigger.rs
index f8dc3a5..d66b31c 100644
--- a/src/scope/trigger.rs
+++ b/src/scope/trigger.rs
@@ -1,10 +1,10 @@
 /***************************************************************************************************
  *
  *  nLabs, LLC
- *  https://nscope.org
+ *  https://getnlab.com
  *  Copyright(c) 2020. All Rights Reserved
  *
- *  This file is part of the nScope API
+ *  This file is part of the nLab API
  *
  **************************************************************************************************/
 
diff --git a/src/version.rs b/src/version.rs
index 9e34c9f..10f2ee2 100644
--- a/src/version.rs
+++ b/src/version.rs
@@ -1,17 +1,17 @@
 /***************************************************************************************************
  *
  *  nLabs, LLC
- *  https://nscope.org
+ *  https://getnlab.com
  *  Copyright(c) 2020. All Rights Reserved
  *
- *  This file is part of the nScope API
+ *  This file is part of the nLab API
  *
  **************************************************************************************************/
 
 use git_version::git_version;
 use regex::Regex;
 
-/// Returns the current version of the nScope API
+/// Returns the current version of the nLab API
 pub fn version() -> String {
     let git_description = git_version!(
         args = ["--always", "--tags", "--dirty"],