diff --git a/TODO.md b/TODO.md
deleted file mode 100644
index 5473e64..0000000
--- a/TODO.md
+++ /dev/null
@@ -1,3 +0,0 @@
-- [ ] rename all `::std::os::raw` instances to ``::core::ffi`
-
-- [ ] I probably don't need my implementations of `NixError` and `NixVerbosity` now, I could just re-export them for sys
diff --git a/nixide-sys/tests/eval.rs b/nixide-sys/tests/eval.rs
index e90dcbe..1a8f58a 100644
--- a/nixide-sys/tests/eval.rs
+++ b/nixide-sys/tests/eval.rs
@@ -1,8 +1,9 @@
 #![cfg(feature = "nix-expr-c")]
 #![cfg(test)]
 
-use std::ffi::{CStr, CString};
-use std::ptr;
+use ::core::ffi::{CStr, c_char, c_uint, c_void};
+use ::std::ffi::CString;
+use ::std::{f64, ptr, slice};
 
 use serial_test::serial;
 
@@ -23,7 +24,7 @@ fn eval_init_and_state_build() {
         let err = nix_libexpr_init(ctx);
         assert_eq!(err, NixErr::Ok, "nix_libexpr_init failed: {err}");
 
-        let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
+        let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
         assert!(!store.is_null());
 
         let builder = nix_eval_state_builder_new(ctx, store);
@@ -58,7 +59,7 @@ fn eval_simple_expression() {
         let err = nix_libexpr_init(ctx);
         assert_eq!(err, NixErr::Ok, "nix_libexpr_init failed: {err}");
 
-        let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
+        let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
         assert!(!store.is_null());
 
         let builder = nix_eval_state_builder_new(ctx, store);
@@ -119,12 +120,9 @@ fn value_construction_and_inspection() {
         // Float
         let float_val = nix_alloc_value(ctx, state);
         assert!(!float_val.is_null());
-        assert_eq!(
-            nix_init_float(ctx, float_val, std::f64::consts::PI),
-            NixErr::Ok
-        );
+        assert_eq!(nix_init_float(ctx, float_val, f64::consts::PI), NixErr::Ok);
         assert_eq!(nix_get_type(ctx, float_val), ValueType::Float);
-        assert!((nix_get_float(ctx, float_val) - std::f64::consts::PI).abs() < 1e-10);
+        assert!((nix_get_float(ctx, float_val) - f64::consts::PI).abs() < 1e-10);
 
         // Bool
         let bool_val = nix_alloc_value(ctx, state);
@@ -145,13 +143,9 @@ fn value_construction_and_inspection() {
         let s = CString::new("hello world").unwrap();
         assert_eq!(nix_init_string(ctx, string_val, s.as_ptr()), NixErr::Ok);
         assert_eq!(nix_get_type(ctx, string_val), ValueType::String);
-        extern "C" fn string_cb(
-            start: *const ::std::os::raw::c_char,
-            n: ::std::os::raw::c_uint,
-            user_data: *mut ::std::os::raw::c_void,
-        ) {
-            let s = unsafe { std::slice::from_raw_parts(start.cast::<u8>(), n as usize) };
-            let s = std::str::from_utf8(s).unwrap();
+        extern "C" fn string_cb(start: *const c_char, n: c_uint, user_data: *mut c_void) {
+            let s = unsafe { slice::from_raw_parts(start.cast::<u8>(), n as usize) };
+            let s = str::from_utf8(s).unwrap();
             let out = user_data.cast::<Option<String>>();
             unsafe { *out = Some(s.to_string()) };
         }
@@ -399,8 +393,7 @@ fn realised_string_and_gc() {
         assert!(!realised.is_null());
         let buf = nix_realised_string_get_buffer_start(realised);
         let len = nix_realised_string_get_buffer_size(realised);
-        let realised_str =
-            std::str::from_utf8(std::slice::from_raw_parts(buf.cast::<u8>(), len)).unwrap();
+        let realised_str = str::from_utf8(slice::from_raw_parts(buf.cast::<u8>(), len)).unwrap();
         assert_eq!(realised_str, "hello world");
         assert_eq!(nix_realised_string_get_store_path_count(realised), 0);
 
@@ -496,7 +489,7 @@ fn multi_argument_function_calls() {
         let err = nix_libexpr_init(ctx);
         assert_eq!(err, NixErr::Ok);
 
-        let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
+        let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
         assert!(!store.is_null());
 
         let builder = nix_eval_state_builder_new(ctx, store);
@@ -584,7 +577,7 @@ fn curried_function_evaluation() {
         let err = nix_libexpr_init(ctx);
         assert_eq!(err, NixErr::Ok);
 
-        let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
+        let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
         assert!(!store.is_null());
 
         let builder = nix_eval_state_builder_new(ctx, store);
@@ -713,7 +706,7 @@ fn thunk_creation_with_init_apply() {
         let err = nix_libexpr_init(ctx);
         assert_eq!(err, NixErr::Ok);
 
-        let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
+        let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
         assert!(!store.is_null());
 
         let builder = nix_eval_state_builder_new(ctx, store);
@@ -792,7 +785,7 @@ fn lookup_path_configuration() {
         let err = nix_libexpr_init(ctx);
         assert_eq!(err, NixErr::Ok);
 
-        let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
+        let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
         assert!(!store.is_null());
 
         let builder = nix_eval_state_builder_new(ctx, store);
@@ -806,7 +799,7 @@ fn lookup_path_configuration() {
 
         let lookup_path_ptrs: Vec<*const _> = lookup_paths.iter().map(|s| s.as_ptr()).collect();
         let mut lookup_path_ptrs_null_terminated = lookup_path_ptrs;
-        lookup_path_ptrs_null_terminated.push(std::ptr::null());
+        lookup_path_ptrs_null_terminated.push(ptr::null());
 
         let set_lookup_err = nix_eval_state_builder_set_lookup_path(
             ctx,
@@ -869,7 +862,7 @@ fn complex_nested_evaluation() {
         let err = nix_libexpr_init(ctx);
         assert_eq!(err, NixErr::Ok);
 
-        let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
+        let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
         assert!(!store.is_null());
 
         let builder = nix_eval_state_builder_new(ctx, store);
@@ -992,7 +985,7 @@ fn evaluation_error_handling() {
         let err = nix_libexpr_init(ctx);
         assert_eq!(err, NixErr::Ok);
 
-        let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
+        let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
         assert!(!store.is_null());
 
         let builder = nix_eval_state_builder_new(ctx, store);
@@ -1043,10 +1036,10 @@ fn evaluation_error_handling() {
         assert_ne!(error_code, NixErr::Ok);
 
         // Try to get error message
-        let mut error_len: std::os::raw::c_uint = 0;
+        let mut error_len: c_uint = 0;
         let error_msg_ptr = nix_err_msg(ctx, ctx, &mut error_len as *mut _);
         if !error_msg_ptr.is_null() && error_len > 0 {
-            let error_msg = std::str::from_utf8(std::slice::from_raw_parts(
+            let error_msg = str::from_utf8(slice::from_raw_parts(
                 error_msg_ptr as *const u8,
                 error_len as usize,
             ))
@@ -1123,7 +1116,7 @@ fn builtin_function_calls() {
         let err = nix_libexpr_init(ctx);
         assert_eq!(err, NixErr::Ok);
 
-        let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
+        let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
         assert!(!store.is_null());
 
         let builder = nix_eval_state_builder_new(ctx, store);
diff --git a/nixide-sys/tests/memory.rs b/nixide-sys/tests/memory.rs
index c7b83db..db82064 100644
--- a/nixide-sys/tests/memory.rs
+++ b/nixide-sys/tests/memory.rs
@@ -1,7 +1,9 @@
 #![cfg(feature = "nix-expr-c")]
 #![cfg(test)]
 
+use core::ffi::{c_char, c_uint, c_void};
 use std::ffi::CString;
+use std::{ptr, slice, str};
 
 use serial_test::serial;
 
@@ -23,7 +25,7 @@ fn value_reference_counting() {
         let err = nix_libexpr_init(ctx);
         assert_eq!(err, NixErr::Ok);
 
-        let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
+        let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
         assert!(!store.is_null());
 
         let builder = nix_eval_state_builder_new(ctx, store);
@@ -87,7 +89,7 @@ fn general_gc_reference_counting() {
         let err = nix_libexpr_init(ctx);
         assert_eq!(err, NixErr::Ok);
 
-        let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
+        let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
         assert!(!store.is_null());
 
         let builder = nix_eval_state_builder_new(ctx, store);
@@ -111,7 +113,7 @@ fn general_gc_reference_counting() {
         assert_eq!(init_err, NixErr::Ok);
 
         // Test general GC reference counting
-        let gc_incref_err = nix_gc_incref(ctx, value as *const ::std::os::raw::c_void);
+        let gc_incref_err = nix_gc_incref(ctx, value as *const c_void);
         assert_eq!(gc_incref_err, NixErr::Ok);
 
         // Value should still be accessible
@@ -119,7 +121,7 @@ fn general_gc_reference_counting() {
         assert_eq!(value_type, ValueType::String);
 
         // Test GC decrement
-        let gc_decref_err = nix_gc_decref(ctx, value as *const ::std::os::raw::c_void);
+        let gc_decref_err = nix_gc_decref(ctx, value as *const c_void);
         assert_eq!(gc_decref_err, NixErr::Ok);
 
         // Final cleanup
@@ -147,7 +149,7 @@ fn manual_garbage_collection() {
         let err = nix_libexpr_init(ctx);
         assert_eq!(err, NixErr::Ok);
 
-        let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
+        let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
         assert!(!store.is_null());
 
         let builder = nix_eval_state_builder_new(ctx, store);
@@ -205,7 +207,7 @@ fn value_copying_and_memory_management() {
         let err = nix_libexpr_init(ctx);
         assert_eq!(err, NixErr::Ok);
 
-        let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
+        let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
         assert!(!store.is_null());
 
         let builder = nix_eval_state_builder_new(ctx, store);
@@ -240,12 +242,12 @@ fn value_copying_and_memory_management() {
 
         // Test string contents using callback
         unsafe extern "C" fn string_callback(
-            start: *const ::std::os::raw::c_char,
-            n: ::std::os::raw::c_uint,
-            user_data: *mut ::std::os::raw::c_void,
+            start: *const c_char,
+            n: c_uint,
+            user_data: *mut c_void,
         ) {
-            let s = unsafe { std::slice::from_raw_parts(start.cast::<u8>(), n as usize) };
-            let s = std::str::from_utf8(s).unwrap_or("");
+            let s = unsafe { slice::from_raw_parts(start.cast::<u8>(), n as usize) };
+            let s = str::from_utf8(s).unwrap_or("");
             let result = unsafe { &mut *(user_data as *mut Option<String>) };
             *result = Some(s.to_string());
         }
@@ -257,14 +259,14 @@ fn value_copying_and_memory_management() {
             ctx,
             original,
             Some(string_callback),
-            &mut original_string as *mut Option<String> as *mut ::std::os::raw::c_void,
+            &mut original_string as *mut Option<String> as *mut c_void,
         );
 
         let _ = nix_get_string(
             ctx,
             copy,
             Some(string_callback),
-            &mut copy_string as *mut Option<String> as *mut ::std::os::raw::c_void,
+            &mut copy_string as *mut Option<String> as *mut c_void,
         );
 
         // Both should have the same string content
@@ -315,7 +317,7 @@ fn complex_value_memory_management() {
         let err = nix_libexpr_init(ctx);
         assert_eq!(err, NixErr::Ok);
 
-        let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
+        let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
         assert!(!store.is_null());
 
         let builder = nix_eval_state_builder_new(ctx, store);
@@ -442,20 +444,20 @@ fn memory_management_error_conditions() {
         assert!(!ctx.is_null());
 
         // Test reference counting with NULL pointers (should handle gracefully)
-        let null_incref_err = nix_gc_incref(ctx, std::ptr::null() as *const ::std::os::raw::c_void);
+        let null_incref_err = nix_gc_incref(ctx, ptr::null() as *const c_void);
 
         // XXX: May succeed or fail depending on implementation. We can't really
         // know, so assert both.
         assert!(null_incref_err == NixErr::Ok || null_incref_err == NixErr::Unknown);
 
-        let null_decref_err = nix_gc_decref(ctx, std::ptr::null() as *const ::std::os::raw::c_void);
+        let null_decref_err = nix_gc_decref(ctx, ptr::null() as *const c_void);
         assert!(null_decref_err == NixErr::Ok || null_decref_err == NixErr::Unknown);
 
-        let null_value_incref_err = nix_value_incref(ctx, std::ptr::null_mut());
+        let null_value_incref_err = nix_value_incref(ctx, ptr::null_mut());
         // Some Nix APIs gracefully handle null pointers and return OK
         assert!(null_value_incref_err == NixErr::Ok || null_value_incref_err == NixErr::Unknown);
 
-        let null_value_decref_err = nix_value_decref(ctx, std::ptr::null_mut());
+        let null_value_decref_err = nix_value_decref(ctx, ptr::null_mut());
         // Some Nix APIs gracefully handle null pointers and return OK
         assert!(null_value_decref_err == NixErr::Ok || null_value_decref_err == NixErr::Unknown);
 
@@ -469,7 +471,7 @@ fn memory_management_error_conditions() {
         let err = nix_libexpr_init(ctx);
         assert_eq!(err, NixErr::Ok);
 
-        let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
+        let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
         assert!(!store.is_null());
 
         let builder = nix_eval_state_builder_new(ctx, store);
@@ -485,10 +487,10 @@ fn memory_management_error_conditions() {
         assert!(!valid_value.is_null());
 
         // Test copying to/from NULL
-        let copy_from_null_err = nix_copy_value(ctx, valid_value, std::ptr::null_mut());
+        let copy_from_null_err = nix_copy_value(ctx, valid_value, ptr::null_mut());
         assert_ne!(copy_from_null_err, NixErr::Ok);
 
-        let copy_to_null_err = nix_copy_value(ctx, std::ptr::null_mut(), valid_value);
+        let copy_to_null_err = nix_copy_value(ctx, ptr::null_mut(), valid_value);
         assert_ne!(copy_to_null_err, NixErr::Ok);
 
         // Clean up
diff --git a/nixide-sys/tests/primop.rs b/nixide-sys/tests/primop.rs
index 2a0b62a..4417621 100644
--- a/nixide-sys/tests/primop.rs
+++ b/nixide-sys/tests/primop.rs
@@ -1,8 +1,10 @@
 #![cfg(feature = "nix-expr-c")]
 #![cfg(test)]
 
+use core::ffi::{c_char, c_uint, c_void};
 use std::ffi::CString;
 use std::sync::atomic::{AtomicU32, Ordering};
+use std::{ptr, slice};
 
 use serial_test::serial;
 
@@ -16,7 +18,7 @@ struct TestPrimOpData {
 
 // Simple PrimOp that adds 1 to an integer argument
 unsafe extern "C" fn add_one_primop(
-    user_data: *mut ::std::os::raw::c_void,
+    user_data: *mut c_void,
     context: *mut NixCContext,
     state: *mut EvalState,
     args: *mut *mut NixValue,
@@ -81,7 +83,7 @@ unsafe extern "C" fn add_one_primop(
 
 // PrimOp that returns a constant string
 unsafe extern "C" fn hello_world_primop(
-    _user_data: *mut ::std::os::raw::c_void,
+    _user_data: *mut c_void,
     context: *mut NixCContext,
     _state: *mut EvalState,
     _args: *mut *mut NixValue,
@@ -93,7 +95,7 @@ unsafe extern "C" fn hello_world_primop(
 
 // PrimOp that takes multiple arguments and concatenates them
 unsafe extern "C" fn concat_strings_primop(
-    _user_data: *mut ::std::os::raw::c_void,
+    _user_data: *mut c_void,
     context: *mut NixCContext,
     state: *mut EvalState,
     args: *mut *mut NixValue,
@@ -135,12 +137,12 @@ unsafe extern "C" fn concat_strings_primop(
 
         // Get string value using callback
         unsafe extern "C" fn string_callback(
-            start: *const ::std::os::raw::c_char,
-            n: ::std::os::raw::c_uint,
-            user_data: *mut ::std::os::raw::c_void,
+            start: *const c_char,
+            n: c_uint,
+            user_data: *mut c_void,
         ) {
-            let s = unsafe { std::slice::from_raw_parts(start.cast::<u8>(), n as usize) };
-            let s = std::str::from_utf8(s).unwrap_or("");
+            let s = unsafe { slice::from_raw_parts(start.cast::<u8>(), n as usize) };
+            let s = str::from_utf8(s).unwrap_or("");
             let result = unsafe { &mut *(user_data as *mut String) };
             result.push_str(s);
         }
@@ -150,7 +152,7 @@ unsafe extern "C" fn concat_strings_primop(
                 context,
                 arg,
                 Some(string_callback),
-                &mut result as *mut String as *mut ::std::os::raw::c_void,
+                &mut result as *mut String as *mut c_void,
             )
         };
     }
@@ -175,7 +177,7 @@ fn primop_allocation_and_registration() {
         let err = nix_libexpr_init(ctx);
         assert_eq!(err, NixErr::Ok);
 
-        let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
+        let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
         assert!(!store.is_null());
 
         let builder = nix_eval_state_builder_new(ctx, store);
@@ -198,7 +200,7 @@ fn primop_allocation_and_registration() {
         let arg_names = [CString::new("x").unwrap()];
         let arg_name_ptrs: Vec<*const _> = arg_names.iter().map(|s| s.as_ptr()).collect();
         let mut arg_name_ptrs_null_terminated = arg_name_ptrs;
-        arg_name_ptrs_null_terminated.push(std::ptr::null());
+        arg_name_ptrs_null_terminated.push(ptr::null());
 
         let name = CString::new("addOne").unwrap();
         let doc = CString::new("Add 1 to the argument").unwrap();
@@ -211,7 +213,7 @@ fn primop_allocation_and_registration() {
             name.as_ptr(),
             arg_name_ptrs_null_terminated.as_mut_ptr(),
             doc.as_ptr(),
-            test_data_ptr as *mut ::std::os::raw::c_void,
+            test_data_ptr as *mut c_void,
         );
 
         if !primop.is_null() {
@@ -259,7 +261,7 @@ fn primop_function_call() {
         let err = nix_libexpr_init(ctx);
         assert_eq!(err, NixErr::Ok);
 
-        let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
+        let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
         assert!(!store.is_null());
 
         let builder = nix_eval_state_builder_new(ctx, store);
@@ -281,7 +283,7 @@ fn primop_function_call() {
         // Create simple hello world PrimOp (no arguments)
         let name = CString::new("helloWorld").unwrap();
         let doc = CString::new("Returns hello world string").unwrap();
-        let mut empty_args: Vec<*const ::std::os::raw::c_char> = vec![std::ptr::null()];
+        let mut empty_args: Vec<*const c_char> = vec![ptr::null()];
 
         let hello_primop = nix_alloc_primop(
             ctx,
@@ -290,7 +292,7 @@ fn primop_function_call() {
             name.as_ptr(),
             empty_args.as_mut_ptr(),
             doc.as_ptr(),
-            std::ptr::null_mut(),
+            ptr::null_mut(),
         );
 
         if !hello_primop.is_null() {
@@ -305,7 +307,7 @@ fn primop_function_call() {
             let result = nix_alloc_value(ctx, state);
             assert!(!result.is_null());
 
-            let call_err = nix_value_call(ctx, state, primop_value, std::ptr::null_mut(), result);
+            let call_err = nix_value_call(ctx, state, primop_value, ptr::null_mut(), result);
             if call_err == NixErr::Ok {
                 // Force the result
                 let force_err = nix_value_force(ctx, state, result);
@@ -316,13 +318,12 @@ fn primop_function_call() {
                 if result_type == ValueType::String {
                     // Get string value
                     unsafe extern "C" fn string_callback(
-                        start: *const ::std::os::raw::c_char,
-                        n: ::std::os::raw::c_uint,
-                        user_data: *mut ::std::os::raw::c_void,
+                        start: *const c_char,
+                        n: c_uint,
+                        user_data: *mut c_void,
                     ) {
-                        let s =
-                            unsafe { std::slice::from_raw_parts(start.cast::<u8>(), n as usize) };
-                        let s = std::str::from_utf8(s).unwrap_or("");
+                        let s = unsafe { slice::from_raw_parts(start.cast::<u8>(), n as usize) };
+                        let s = str::from_utf8(s).unwrap_or("");
                         let result = unsafe { &mut *(user_data as *mut Option<String>) };
                         *result = Some(s.to_string());
                     }
@@ -332,7 +333,7 @@ fn primop_function_call() {
                         ctx,
                         result,
                         Some(string_callback),
-                        &mut string_result as *mut Option<String> as *mut ::std::os::raw::c_void,
+                        &mut string_result as *mut Option<String> as *mut c_void,
                     );
 
                     // Verify we got the expected string
@@ -374,7 +375,7 @@ fn primop_with_arguments() {
         let err = nix_libexpr_init(ctx);
         assert_eq!(err, NixErr::Ok);
 
-        let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
+        let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
         assert!(!store.is_null());
 
         let builder = nix_eval_state_builder_new(ctx, store);
@@ -397,7 +398,7 @@ fn primop_with_arguments() {
         let arg_names = [CString::new("x").unwrap()];
         let arg_name_ptrs: Vec<*const _> = arg_names.iter().map(|s| s.as_ptr()).collect();
         let mut arg_name_ptrs_null_terminated = arg_name_ptrs;
-        arg_name_ptrs_null_terminated.push(std::ptr::null());
+        arg_name_ptrs_null_terminated.push(ptr::null());
 
         let name = CString::new("addOne").unwrap();
         let doc = CString::new("Add 1 to the argument").unwrap();
@@ -409,7 +410,7 @@ fn primop_with_arguments() {
             name.as_ptr(),
             arg_name_ptrs_null_terminated.as_mut_ptr(),
             doc.as_ptr(),
-            test_data_ptr as *mut ::std::os::raw::c_void,
+            test_data_ptr as *mut c_void,
         );
 
         if !add_primop.is_null() {
@@ -480,7 +481,7 @@ fn primop_multi_argument() {
         let err = nix_libexpr_init(ctx);
         assert_eq!(err, NixErr::Ok);
 
-        let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
+        let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
         assert!(!store.is_null());
 
         let builder = nix_eval_state_builder_new(ctx, store);
@@ -496,7 +497,7 @@ fn primop_multi_argument() {
         let arg_names = [CString::new("s1").unwrap(), CString::new("s2").unwrap()];
         let arg_name_ptrs: Vec<*const _> = arg_names.iter().map(|s| s.as_ptr()).collect();
         let mut arg_name_ptrs_null_terminated = arg_name_ptrs;
-        arg_name_ptrs_null_terminated.push(std::ptr::null());
+        arg_name_ptrs_null_terminated.push(ptr::null());
 
         let name = CString::new("concatStrings").unwrap();
         let doc = CString::new("Concatenate two strings").unwrap();
@@ -508,7 +509,7 @@ fn primop_multi_argument() {
             name.as_ptr(),
             arg_name_ptrs_null_terminated.as_mut_ptr(),
             doc.as_ptr(),
-            std::ptr::null_mut(),
+            ptr::null_mut(),
         );
 
         if !concat_primop.is_null() {
@@ -548,13 +549,12 @@ fn primop_multi_argument() {
                 let result_type = nix_get_type(ctx, result);
                 if result_type == ValueType::String {
                     unsafe extern "C" fn string_callback(
-                        start: *const ::std::os::raw::c_char,
-                        n: ::std::os::raw::c_uint,
-                        user_data: *mut ::std::os::raw::c_void,
+                        start: *const c_char,
+                        n: c_uint,
+                        user_data: *mut c_void,
                     ) {
-                        let s =
-                            unsafe { std::slice::from_raw_parts(start.cast::<u8>(), n as usize) };
-                        let s = std::str::from_utf8(s).unwrap_or("");
+                        let s = unsafe { slice::from_raw_parts(start.cast::<u8>(), n as usize) };
+                        let s = str::from_utf8(s).unwrap_or("");
                         let result = unsafe { &mut *(user_data as *mut Option<String>) };
                         *result = Some(s.to_string());
                     }
@@ -564,7 +564,7 @@ fn primop_multi_argument() {
                         ctx,
                         result,
                         Some(string_callback),
-                        &mut string_result as *mut Option<String> as *mut ::std::os::raw::c_void,
+                        &mut string_result as *mut Option<String> as *mut c_void,
                     );
 
                     // Verify concatenation worked
@@ -601,7 +601,7 @@ fn primop_error_handling() {
         let err = nix_libexpr_init(ctx);
         assert_eq!(err, NixErr::Ok);
 
-        let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
+        let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
         assert!(!store.is_null());
 
         let builder = nix_eval_state_builder_new(ctx, store);
@@ -616,7 +616,7 @@ fn primop_error_handling() {
         // Test invalid PrimOp allocation (NULL callback)
         let name = CString::new("invalid").unwrap();
         let doc = CString::new("Invalid PrimOp").unwrap();
-        let mut empty_args: Vec<*const ::std::os::raw::c_char> = vec![std::ptr::null()];
+        let mut empty_args: Vec<*const c_char> = vec![ptr::null()];
 
         let _invalid_primop = nix_alloc_primop(
             ctx,
@@ -625,7 +625,7 @@ fn primop_error_handling() {
             name.as_ptr(),
             empty_args.as_mut_ptr(),
             doc.as_ptr(),
-            std::ptr::null_mut(),
+            ptr::null_mut(),
         );
 
         // Test initializing value with NULL PrimOp (should fail)
diff --git a/nixide-sys/tests/store.rs b/nixide-sys/tests/store.rs
index 1e85322..31cbfab 100644
--- a/nixide-sys/tests/store.rs
+++ b/nixide-sys/tests/store.rs
@@ -1,8 +1,9 @@
 #![cfg(feature = "nix-store-c")]
 #![cfg(test)]
 
+use core::ffi::{c_char, c_uint, c_void};
 use std::ffi::CString;
-use std::ptr;
+use std::{ptr, slice, str};
 
 use serial_test::serial;
 
@@ -61,13 +62,9 @@ fn parse_and_clone_free_store_path() {
 #[test]
 #[serial]
 fn store_get_uri_and_storedir() {
-    unsafe extern "C" fn string_callback(
-        start: *const ::std::os::raw::c_char,
-        n: ::std::os::raw::c_uint,
-        user_data: *mut ::std::os::raw::c_void,
-    ) {
-        let s = unsafe { std::slice::from_raw_parts(start.cast::<u8>(), n as usize) };
-        let s = std::str::from_utf8(s).unwrap();
+    unsafe extern "C" fn string_callback(start: *const c_char, n: c_uint, user_data: *mut c_void) {
+        let s = unsafe { slice::from_raw_parts(start.cast::<u8>(), n as usize) };
+        let s = str::from_utf8(s).unwrap();
         let out = user_data.cast::<Option<String>>();
         unsafe { *out = Some(s.to_string()) };
     }
@@ -116,13 +113,9 @@ fn libstore_init_no_load_config() {
 #[test]
 #[serial]
 fn store_is_valid_path_and_real_path() {
-    unsafe extern "C" fn string_callback(
-        start: *const ::std::os::raw::c_char,
-        n: ::std::os::raw::c_uint,
-        user_data: *mut ::std::os::raw::c_void,
-    ) {
-        let s = unsafe { std::slice::from_raw_parts(start.cast::<u8>(), n as usize) };
-        let s = std::str::from_utf8(s).unwrap();
+    unsafe extern "C" fn string_callback(start: *const c_char, n: c_uint, user_data: *mut c_void) {
+        let s = unsafe { slice::from_raw_parts(start.cast::<u8>(), n as usize) };
+        let s = str::from_utf8(s).unwrap();
         let out = user_data.cast::<Option<String>>();
         unsafe { *out = Some(s.to_string()) };
     }
@@ -133,7 +126,7 @@ fn store_is_valid_path_and_real_path() {
         let err = nix_libstore_init(ctx);
         assert_eq!(err, NixErr::Ok);
 
-        let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
+        let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
         assert!(!store.is_null());
 
         // Use a dummy path (should not be valid, but should not crash)
@@ -164,13 +157,9 @@ fn store_is_valid_path_and_real_path() {
 #[test]
 #[serial]
 fn store_path_name() {
-    unsafe extern "C" fn string_callback(
-        start: *const ::std::os::raw::c_char,
-        n: ::std::os::raw::c_uint,
-        user_data: *mut ::std::os::raw::c_void,
-    ) {
-        let s = unsafe { std::slice::from_raw_parts(start.cast::<u8>(), n as usize) };
-        let s = std::str::from_utf8(s).unwrap();
+    unsafe extern "C" fn string_callback(start: *const c_char, n: c_uint, user_data: *mut c_void) {
+        let s = unsafe { slice::from_raw_parts(start.cast::<u8>(), n as usize) };
+        let s = str::from_utf8(s).unwrap();
         let out = user_data.cast::<Option<String>>();
         unsafe { *out = Some(s.to_string()) };
     }
@@ -181,7 +170,7 @@ fn store_path_name() {
         let err = nix_libstore_init(ctx);
         assert_eq!(err, NixErr::Ok);
 
-        let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
+        let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
         assert!(!store.is_null());
 
         let path_str = CString::new("/nix/store/foo-bar-baz").unwrap();
@@ -202,13 +191,9 @@ fn store_path_name() {
 #[test]
 #[serial]
 fn store_get_version() {
-    unsafe extern "C" fn string_callback(
-        start: *const ::std::os::raw::c_char,
-        n: ::std::os::raw::c_uint,
-        user_data: *mut ::std::os::raw::c_void,
-    ) {
-        let s = unsafe { std::slice::from_raw_parts(start.cast::<u8>(), n as usize) };
-        let s = std::str::from_utf8(s).unwrap();
+    unsafe extern "C" fn string_callback(start: *const c_char, n: c_uint, user_data: *mut c_void) {
+        let s = unsafe { slice::from_raw_parts(start.cast::<u8>(), n as usize) };
+        let s = str::from_utf8(s).unwrap();
         let out = user_data.cast::<Option<String>>();
         unsafe { *out = Some(s.to_string()) };
     }
@@ -219,7 +204,7 @@ fn store_get_version() {
         let err = nix_libstore_init(ctx);
         assert_eq!(err, NixErr::Ok);
 
-        let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
+        let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
         assert!(!store.is_null());
 
         let mut version: Option<String> = None;
@@ -238,8 +223,8 @@ fn store_get_version() {
 #[serial]
 fn store_realise_and_copy_closure() {
     unsafe extern "C" fn realise_callback(
-        _userdata: *mut ::std::os::raw::c_void,
-        outname: *const ::std::os::raw::c_char,
+        _userdata: *mut c_void,
+        outname: *const c_char,
         out: *const StorePath,
     ) {
         // Just check that callback is called with non-null pointers
@@ -253,7 +238,7 @@ fn store_realise_and_copy_closure() {
         let err = nix_libstore_init(ctx);
         assert_eq!(err, NixErr::Ok);
 
-        let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
+        let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
         assert!(!store.is_null());
 
         // Use a dummy path (should not crash, may not realise)
@@ -265,7 +250,7 @@ fn store_realise_and_copy_closure() {
                 ctx,
                 store,
                 store_path,
-                std::ptr::null_mut(),
+                ptr::null_mut(),
                 Some(realise_callback),
             );
 
diff --git a/nixide-sys/tests/util.rs b/nixide-sys/tests/util.rs
index 5abfbf7..70a2872 100644
--- a/nixide-sys/tests/util.rs
+++ b/nixide-sys/tests/util.rs
@@ -1,7 +1,9 @@
 #![cfg(feature = "nix-util-c")]
 #![cfg(test)]
 
-use std::ffi::{CStr, CString};
+use core::ffi::{CStr, c_char, c_uint, c_void};
+use std::ffi::CString;
+use std::{slice, str};
 
 use serial_test::serial;
 
@@ -47,13 +49,9 @@ fn version_get() {
 #[test]
 #[serial]
 fn setting_set_and_get() {
-    unsafe extern "C" fn string_callback(
-        start: *const ::std::os::raw::c_char,
-        n: ::std::os::raw::c_uint,
-        user_data: *mut ::std::os::raw::c_void,
-    ) {
-        let s = unsafe { std::slice::from_raw_parts(start.cast::<u8>(), n as usize) };
-        let s = std::str::from_utf8(s).unwrap();
+    unsafe extern "C" fn string_callback(start: *const c_char, n: c_uint, user_data: *mut c_void) {
+        let s = unsafe { slice::from_raw_parts(start.cast::<u8>(), n as usize) };
+        let s = str::from_utf8(s).unwrap();
         let out = user_data.cast::<Option<String>>();
         *unsafe { &mut *out } = Some(s.to_string());
     }
@@ -98,13 +96,9 @@ fn setting_set_and_get() {
 #[test]
 #[serial]
 fn error_handling_apis() {
-    unsafe extern "C" fn string_callback(
-        start: *const ::std::os::raw::c_char,
-        n: ::std::os::raw::c_uint,
-        user_data: *mut ::std::os::raw::c_void,
-    ) {
-        let s = unsafe { std::slice::from_raw_parts(start.cast::<u8>(), n as usize) };
-        let s = std::str::from_utf8(s).unwrap();
+    unsafe extern "C" fn string_callback(start: *const c_char, n: c_uint, user_data: *mut c_void) {
+        let s = unsafe { slice::from_raw_parts(start.cast::<u8>(), n as usize) };
+        let s = str::from_utf8(s).unwrap();
         let out = user_data.cast::<Option<String>>();
         *unsafe { &mut *out } = Some(s.to_string());
     }
@@ -125,10 +119,10 @@ fn error_handling_apis() {
         assert_eq!(code, NixErr::Unknown);
 
         // Get error message
-        let mut len: std::os::raw::c_uint = 0;
+        let mut len: c_uint = 0;
         let err_msg_ptr = nix_err_msg(ctx, ctx, &mut len as *mut _);
         if !err_msg_ptr.is_null() && len > 0 {
-            let err_msg = std::str::from_utf8(std::slice::from_raw_parts(
+            let err_msg = str::from_utf8(slice::from_raw_parts(
                 err_msg_ptr as *const u8,
                 len as usize,
             ))
diff --git a/nixide/src/errors/nix_error.rs b/nixide/src/errors/nix_error.rs
index c239e5f..a2c7789 100644
--- a/nixide/src/errors/nix_error.rs
+++ b/nixide/src/errors/nix_error.rs
@@ -94,7 +94,7 @@ pub enum NixError {
     /// [NixError::Undocumented] has no equivalent in the `libnix` api.
     /// This is solely a language difference between C++ and Rust, since
     /// [sys::NixErr] is defined over the *"continuous" (not realy)*
-    /// type [std::os::raw::c_int].
+    /// type [::core::ffi::c_int].
     Undocumented(sys::NixErr),
 }
 
diff --git a/nixide/src/flake/flake_reference.rs b/nixide/src/flake/flake_reference.rs
index 2872578..9b4e619 100644
--- a/nixide/src/flake/flake_reference.rs
+++ b/nixide/src/flake/flake_reference.rs
@@ -1,5 +1,4 @@
-use std::ffi::c_void;
-use std::os::raw::c_char;
+use std::ffi::{c_char, c_void};
 use std::ptr::{NonNull, null_mut};
 
 use super::{FetchersSettings, FlakeReferenceParseFlags, FlakeSettings};
diff --git a/nixide/src/flake/flake_reference_parse_flags.rs b/nixide/src/flake/flake_reference_parse_flags.rs
index 2b47aea..758023a 100644
--- a/nixide/src/flake/flake_reference_parse_flags.rs
+++ b/nixide/src/flake/flake_reference_parse_flags.rs
@@ -1,4 +1,4 @@
-use std::os::raw::c_char;
+use std::ffi::c_char;
 use std::ptr::NonNull;
 
 use super::FlakeSettings;