diff --git a/build/egl.rs b/build/egl.rs
index d82aa654..f2403e5b 100644
--- a/build/egl.rs
+++ b/build/egl.rs
@@ -155,11 +155,13 @@ fn write_egl_procs<W: Write>(f: &mut W) -> anyhow::Result<()> {
         writeln!(f, "       if self.{}.is_null() {{", name)?;
         writeln!(f, "           panic!(\"Could not load `{}`\");", name)?;
         writeln!(f, "       }}")?;
+        writeln!(f, "       unsafe {{")?;
         writeln!(
             f,
-            "       ptr::read(&self.{} as *const *mut u8 as *const unsafe extern fn({}) -> {})({})",
+            "           ptr::read(&self.{} as *const *mut u8 as *const unsafe extern fn({}) -> {})({})",
             name, args_tys, ret, args_names
         )?;
+        writeln!(f, "       }}")?;
         writeln!(f, "    }}")?;
     }
     writeln!(f, "}}")?;
diff --git a/jay-config/src/_private/client.rs b/jay-config/src/_private/client.rs
index 92d6e2ef..a0de534e 100644
--- a/jay-config/src/_private/client.rs
+++ b/jay-config/src/_private/client.rs
@@ -164,7 +164,7 @@ unsafe fn with_client<T, F: FnOnce(&Client) -> T>(data: *const u8, f: F) -> T {
             self.cell.set(self.val);
         }
     }
-    CLIENT.with(|cell| {
+    CLIENT.with(|cell| unsafe {
         let client = data as *const Client;
         Rc::increment_strong_count(client);
         let client = Rc::from_raw(client);
@@ -190,14 +190,16 @@ impl<T: Config> ConfigEntryGen<T> {
         size: usize,
     ) -> *const u8 {
         logging::init();
-        init(
-            srv_data,
-            srv_unref,
-            srv_handler,
-            init_data,
-            size,
-            T::configure,
-        )
+        unsafe {
+            init(
+                srv_data,
+                srv_unref,
+                srv_handler,
+                init_data,
+                size,
+                T::configure,
+            )
+        }
     }
 }
 
@@ -239,21 +241,25 @@ pub unsafe extern "C" fn init(
         pressed_keysym: Cell::new(None),
         feat_mod_mask: Cell::new(false),
     });
-    let init = slice::from_raw_parts(init, size);
+    let init = unsafe { slice::from_raw_parts(init, size) };
     client.handle_init_msg(init);
     Rc::into_raw(client) as *const u8
 }
 
 pub unsafe extern "C" fn unref(data: *const u8) {
     let client = data as *const Client;
-    drop(Rc::from_raw(client));
+    unsafe {
+        drop(Rc::from_raw(client));
+    }
 }
 
 pub unsafe extern "C" fn handle_msg(data: *const u8, msg: *const u8, size: usize) {
-    with_client(data, |client| {
-        let msg = slice::from_raw_parts(msg, size);
-        client.handle_msg(msg);
-    });
+    unsafe {
+        with_client(data, |client| {
+            let msg = slice::from_raw_parts(msg, size);
+            client.handle_msg(msg);
+        });
+    }
 }
 
 macro_rules! get_response {
diff --git a/jay-config/src/lib.rs b/jay-config/src/lib.rs
index bb831d12..68e1ffa8 100644
--- a/jay-config/src/lib.rs
+++ b/jay-config/src/lib.rs
@@ -41,6 +41,7 @@
     clippy::single_char_add_str,
     clippy::single_match
 )]
+#![warn(unsafe_op_in_unsafe_fn)]
 
 use {
     crate::{_private::ipc::WorkspaceSource, keyboard::ModifiedKeySym, video::Connector},
diff --git a/src/async_engine/ae_task.rs b/src/async_engine/ae_task.rs
index 51e24393..e980c89c 100644
--- a/src/async_engine/ae_task.rs
+++ b/src/async_engine/ae_task.rs
@@ -49,27 +49,31 @@ impl<T: 'static, F: Future<Output = T>> SpawnedFutureVTableProxy<T, F> {
     };
 
     unsafe fn poll(data: *mut u8, ctx: &mut Context<'_>) -> Poll<T> {
-        let task = (data as *const Task<T, F>).deref();
-        if &task.state & COMPLETED == 0 {
-            task.waker.set(Some(ctx.waker().clone()));
-            Poll::Pending
-        } else if &task.state & EMPTIED == 0 {
-            task.state.or_assign(EMPTIED);
-            Poll::Ready(ptr::read(&*task.data.get().deref().result))
-        } else {
-            panic!("Future polled after it has already been emptied");
+        unsafe {
+            let task = (data as *const Task<T, F>).deref();
+            if &task.state & COMPLETED == 0 {
+                task.waker.set(Some(ctx.waker().clone()));
+                Poll::Pending
+            } else if &task.state & EMPTIED == 0 {
+                task.state.or_assign(EMPTIED);
+                Poll::Ready(ptr::read(&*task.data.get().deref().result))
+            } else {
+                panic!("Future polled after it has already been emptied");
+            }
         }
     }
 
     unsafe fn drop(data: *mut u8) {
-        {
-            let task = (data as *const Task<T, F>).deref();
-            task.state.or_assign(CANCELLED);
-            if &task.state & RUNNING == 0 {
-                task.drop_data();
+        unsafe {
+            {
+                let task = (data as *const Task<T, F>).deref();
+                task.state.or_assign(CANCELLED);
+                if &task.state & RUNNING == 0 {
+                    task.drop_data();
+                }
             }
+            Task::<T, F>::dec_ref_count(data as _);
         }
-        Task::<T, F>::dec_ref_count(data as _);
     }
 }
 
@@ -160,27 +164,33 @@ impl<T, F: Future<Output = T>> Task<T, F> {
     );
 
     unsafe fn run_proxy(data: *const u8, run: bool) {
-        let task = data as *const Self;
-        if run {
-            task.deref().run();
-        } else {
-            Self::task_runnable_dropped(task);
+        unsafe {
+            let task = data as *const Self;
+            if run {
+                task.deref().run();
+            } else {
+                Self::task_runnable_dropped(task);
+            }
+            Self::dec_ref_count(task);
         }
-        Self::dec_ref_count(task);
     }
 
     #[cold]
     unsafe fn task_runnable_dropped(task: *const Self) {
-        let task = task.deref();
-        task.state.and_assign(!RUNNING);
-        if task.state.get() & CANCELLED != 0 {
-            task.drop_data();
+        unsafe {
+            let task = task.deref();
+            task.state.and_assign(!RUNNING);
+            if task.state.get() & CANCELLED != 0 {
+                task.drop_data();
+            }
         }
     }
 
     unsafe fn dec_ref_count(slf: *const Self) {
-        if slf.deref().ref_count.fetch_sub(1) == 1 {
-            drop(Box::from_raw(slf as *mut Self));
+        unsafe {
+            if slf.deref().ref_count.fetch_sub(1) == 1 {
+                drop(Box::from_raw(slf as *mut Self));
+            }
         }
     }
 
@@ -189,80 +199,92 @@ impl<T, F: Future<Output = T>> Task<T, F> {
     }
 
     unsafe fn waker_clone(data: *const ()) -> RawWaker {
-        let task = &mut *(data as *mut Self);
-        task.inc_ref_count();
-        RawWaker::new(data, Self::VTABLE)
+        unsafe {
+            let task = &mut *(data as *mut Self);
+            task.inc_ref_count();
+            RawWaker::new(data, Self::VTABLE)
+        }
     }
 
     unsafe fn waker_wake(data: *const ()) {
-        Self::waker_wake_by_ref(data);
-        Self::waker_drop(data);
+        unsafe {
+            Self::waker_wake_by_ref(data);
+            Self::waker_drop(data);
+        }
     }
 
     unsafe fn waker_wake_by_ref(data: *const ()) {
-        (data as *const Self).deref().schedule_run();
+        unsafe {
+            (data as *const Self).deref().schedule_run();
+        }
     }
 
     unsafe fn waker_drop(data: *const ()) {
-        Self::dec_ref_count(data as _)
+        unsafe { Self::dec_ref_count(data as _) }
     }
 
     unsafe fn schedule_run(&self) {
-        if &self.state & (COMPLETED | CANCELLED) == 0 {
-            if &self.state & RUNNING == 0 {
-                self.state.or_assign(RUNNING);
-                self.inc_ref_count();
-                let data = self as *const _ as _;
-                self.queue.push(
-                    Runnable {
-                        data,
-                        run: Self::run_proxy,
-                    },
-                    self.phase,
-                );
-            } else {
-                self.state.or_assign(RUN_AGAIN);
+        unsafe {
+            if &self.state & (COMPLETED | CANCELLED) == 0 {
+                if &self.state & RUNNING == 0 {
+                    self.state.or_assign(RUNNING);
+                    self.inc_ref_count();
+                    let data = self as *const _ as _;
+                    self.queue.push(
+                        Runnable {
+                            data,
+                            run: Self::run_proxy,
+                        },
+                        self.phase,
+                    );
+                } else {
+                    self.state.or_assign(RUN_AGAIN);
+                }
             }
         }
     }
 
     unsafe fn run(&self) {
-        if &self.state & CANCELLED == 0 {
-            let data = self.data.get().deref_mut();
-            self.inc_ref_count();
-            let raw_waker = RawWaker::new(self as *const _ as _, Self::VTABLE);
-            let waker = Waker::from_raw(raw_waker);
+        unsafe {
+            if &self.state & CANCELLED == 0 {
+                let data = self.data.get().deref_mut();
+                self.inc_ref_count();
+                let raw_waker = RawWaker::new(self as *const _ as _, Self::VTABLE);
+                let waker = Waker::from_raw(raw_waker);
 
-            let mut ctx = Context::from_waker(&waker);
-            let poll = {
-                dynamic_zone!(self.zone);
-                Pin::new_unchecked(&mut *data.future).poll(&mut ctx)
-            };
-            if let Poll::Ready(d) = poll {
-                ManuallyDrop::drop(&mut data.future);
-                ptr::write(&mut data.result, ManuallyDrop::new(d));
-                self.state.or_assign(COMPLETED);
-                if let Some(waker) = self.waker.take() {
-                    waker.wake();
+                let mut ctx = Context::from_waker(&waker);
+                let poll = {
+                    dynamic_zone!(self.zone);
+                    Pin::new_unchecked(&mut *data.future).poll(&mut ctx)
+                };
+                if let Poll::Ready(d) = poll {
+                    ManuallyDrop::drop(&mut data.future);
+                    ptr::write(&mut data.result, ManuallyDrop::new(d));
+                    self.state.or_assign(COMPLETED);
+                    if let Some(waker) = self.waker.take() {
+                        waker.wake();
+                    }
                 }
             }
-        }
 
-        self.state.and_assign(!RUNNING);
+            self.state.and_assign(!RUNNING);
 
-        if &self.state & CANCELLED != 0 {
-            self.drop_data();
-        } else if &self.state & RUN_AGAIN != 0 {
-            self.state.and_assign(!RUN_AGAIN);
-            self.schedule_run()
+            if &self.state & CANCELLED != 0 {
+                self.drop_data();
+            } else if &self.state & RUN_AGAIN != 0 {
+                self.state.and_assign(!RUN_AGAIN);
+                self.schedule_run()
+            }
         }
     }
 
     unsafe fn drop_data(&self) {
-        if &self.state & COMPLETED == 0 {
-            ManuallyDrop::drop(&mut self.data.get().deref_mut().future);
-        } else if &self.state & EMPTIED == 0 {
-            ManuallyDrop::drop(&mut self.data.get().deref_mut().result);
+        unsafe {
+            if &self.state & COMPLETED == 0 {
+                ManuallyDrop::drop(&mut self.data.get().deref_mut().future);
+            } else if &self.state & EMPTIED == 0 {
+                ManuallyDrop::drop(&mut self.data.get().deref_mut().result);
+            }
         }
     }
 }
diff --git a/src/clientmem.rs b/src/clientmem.rs
index 1f763a8d..8463eb1d 100644
--- a/src/clientmem.rs
+++ b/src/clientmem.rs
@@ -194,39 +194,43 @@ thread_local! {
 }
 
 unsafe fn kill() -> ! {
-    c::signal(c::SIGBUS, c::SIG_DFL);
-    raise(c::SIGBUS);
+    unsafe {
+        c::signal(c::SIGBUS, c::SIG_DFL);
+        raise(c::SIGBUS);
+    }
     unreachable!();
 }
 
 unsafe extern "C" fn sigbus(sig: i32, info: &c::siginfo_t, _ucontext: *mut c::c_void) {
-    assert_eq!(sig, c::SIGBUS);
-    let mut memr_ptr = MEM.get();
-    while !memr_ptr.is_null() {
-        let memr = &*memr_ptr;
-        let mem = &*memr.mem;
-        let lo = mem.data as *mut u8 as usize;
-        let hi = lo + mem.len();
-        let fault_addr = info.si_addr() as usize;
-        if fault_addr < lo || fault_addr >= hi {
-            memr_ptr = memr.outer;
-            continue;
+    unsafe {
+        assert_eq!(sig, c::SIGBUS);
+        let mut memr_ptr = MEM.get();
+        while !memr_ptr.is_null() {
+            let memr = &*memr_ptr;
+            let mem = &*memr.mem;
+            let lo = mem.data as *mut u8 as usize;
+            let hi = lo + mem.len();
+            let fault_addr = info.si_addr() as usize;
+            if fault_addr < lo || fault_addr >= hi {
+                memr_ptr = memr.outer;
+                continue;
+            }
+            let res = c::mmap64(
+                lo as _,
+                hi - lo,
+                c::PROT_WRITE | c::PROT_READ,
+                c::MAP_ANONYMOUS | c::MAP_PRIVATE | c::MAP_FIXED,
+                -1,
+                0,
+            );
+            if res == c::MAP_FAILED {
+                kill();
+            }
+            mem.failed.set(true);
+            return;
         }
-        let res = c::mmap64(
-            lo as _,
-            hi - lo,
-            c::PROT_WRITE | c::PROT_READ,
-            c::MAP_ANONYMOUS | c::MAP_PRIVATE | c::MAP_FIXED,
-            -1,
-            0,
-        );
-        if res == c::MAP_FAILED {
-            kill();
-        }
-        mem.failed.set(true);
-        return;
+        kill();
     }
-    kill();
 }
 
 pub fn init() -> Result<(), ClientMemError> {
diff --git a/src/config.rs b/src/config.rs
index 22bc2600..4c6e8297 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -170,7 +170,9 @@ unsafe extern "C" fn default_client_init(
     extern "C" fn configure() {
         jay_toml_config::configure();
     }
-    jay_config::_private::client::init(srv_data, srv_unref, srv_handler, msg, size, configure)
+    unsafe {
+        jay_config::_private::client::init(srv_data, srv_unref, srv_handler, msg, size, configure)
+    }
 }
 
 impl ConfigProxy {
@@ -279,11 +281,11 @@ impl ConfigProxy {
             return Err(ConfigError::CopyConfigFile(e));
         }
         let unlink = UnlinkOnDrop(&copy);
-        let lib = match Library::new(&copy) {
+        let lib = match unsafe { Library::new(&copy) } {
             Ok(l) => l,
             Err(e) => return Err(ConfigError::CouldNotLoadLibrary(e)),
         };
-        let entry = lib.get::<&'static ConfigEntry>(b"JAY_CONFIG_ENTRY_V1\0");
+        let entry = unsafe { lib.get::<&'static ConfigEntry>(b"JAY_CONFIG_ENTRY_V1\0") };
         let entry = match entry {
             Ok(e) => *e,
             Err(e) => return Err(ConfigError::LibraryDoesNotContainEntry(e)),
@@ -295,18 +297,22 @@ impl ConfigProxy {
 
 unsafe extern "C" fn unref(data: *const u8) {
     let server = data as *const ConfigProxyHandler;
-    drop(Rc::from_raw(server));
+    unsafe {
+        drop(Rc::from_raw(server));
+    }
 }
 
 unsafe extern "C" fn handle_msg(data: *const u8, msg: *const u8, size: usize) {
-    let server = (data as *const ConfigProxyHandler).deref();
-    if server.dropped.get() {
-        return;
+    unsafe {
+        let server = (data as *const ConfigProxyHandler).deref();
+        if server.dropped.get() {
+            return;
+        }
+        let rc = Rc::from_raw(server);
+        let msg = std::slice::from_raw_parts(msg, size);
+        rc.handle_request(msg);
+        mem::forget(rc);
     }
-    let rc = Rc::from_raw(server);
-    let msg = std::slice::from_raw_parts(msg, size);
-    rc.handle_request(msg);
-    mem::forget(rc);
 }
 
 pub struct InvokedShortcut {
diff --git a/src/gfx_apis/gl/egl.rs b/src/gfx_apis/gl/egl.rs
index a6237cb4..b6f1cab4 100644
--- a/src/gfx_apis/gl/egl.rs
+++ b/src/gfx_apis/gl/egl.rs
@@ -83,12 +83,12 @@ unsafe extern "C" fn egl_log(
         _ => Level::Warn,
     };
     let command = if !command.is_null() {
-        CStr::from_ptr(command).to_bytes()
+        unsafe { CStr::from_ptr(command).to_bytes() }
     } else {
         b"none"
     };
     let message = if !message.is_null() {
-        CStr::from_ptr(message).to_bytes()
+        unsafe { CStr::from_ptr(message).to_bytes() }
     } else {
         b"none"
     };
diff --git a/src/gfx_apis/gl/egl/context.rs b/src/gfx_apis/gl/egl/context.rs
index c72ea95f..bf511d70 100644
--- a/src/gfx_apis/gl/egl/context.rs
+++ b/src/gfx_apis/gl/egl/context.rs
@@ -76,24 +76,30 @@ impl EglContext {
         &self,
         f: F,
     ) -> Result<T, RenderError> {
-        if (self.dpy.egl.eglMakeCurrent)(
-            self.dpy.dpy,
-            EGLSurface::none(),
-            EGLSurface::none(),
-            self.ctx,
-        ) == EGL_FALSE
-        {
-            return Err(RenderError::MakeCurrent);
+        unsafe {
+            if (self.dpy.egl.eglMakeCurrent)(
+                self.dpy.dpy,
+                EGLSurface::none(),
+                EGLSurface::none(),
+                self.ctx,
+            ) == EGL_FALSE
+            {
+                return Err(RenderError::MakeCurrent);
+            }
+            let prev = CURRENT.get();
+            CURRENT.set(self.ctx);
+            let res = f();
+            if (self.dpy.egl.eglMakeCurrent)(
+                self.dpy.dpy,
+                EGLSurface::none(),
+                EGLSurface::none(),
+                prev,
+            ) == EGL_FALSE
+            {
+                panic!("Could not restore EGLContext");
+            }
+            CURRENT.set(prev);
+            res
         }
-        let prev = CURRENT.get();
-        CURRENT.set(self.ctx);
-        let res = f();
-        if (self.dpy.egl.eglMakeCurrent)(self.dpy.dpy, EGLSurface::none(), EGLSurface::none(), prev)
-            == EGL_FALSE
-        {
-            panic!("Could not restore EGLContext");
-        }
-        CURRENT.set(prev);
-        res
     }
 }
diff --git a/src/gfx_apis/gl/egl/display.rs b/src/gfx_apis/gl/egl/display.rs
index fa7d5d52..e3995681 100644
--- a/src/gfx_apis/gl/egl/display.rs
+++ b/src/gfx_apis/gl/egl/display.rs
@@ -312,21 +312,23 @@ unsafe fn query_formats(
 ) -> Result<AHashMap<u32, EglFormat>, RenderError> {
     let mut vec = vec![];
     let mut num = 0;
-    let res = procs.eglQueryDmaBufFormatsEXT(dpy, num, ptr::null_mut(), &mut num);
+    let res = unsafe { procs.eglQueryDmaBufFormatsEXT(dpy, num, ptr::null_mut(), &mut num) };
     if res != EGL_TRUE {
         return Err(RenderError::QueryDmaBufFormats);
     }
     vec.reserve_exact(num as usize);
-    let res = procs.eglQueryDmaBufFormatsEXT(dpy, num, vec.as_mut_ptr(), &mut num);
+    let res = unsafe { procs.eglQueryDmaBufFormatsEXT(dpy, num, vec.as_mut_ptr(), &mut num) };
     if res != EGL_TRUE {
         return Err(RenderError::QueryDmaBufFormats);
     }
-    vec.set_len(num as usize);
+    unsafe {
+        vec.set_len(num as usize);
+    }
     let mut res = AHashMap::new();
     let formats = formats();
     for fmt in vec {
         if let Some(format) = formats.get(&(fmt as u32)) {
-            let (modifiers, external_only) = query_modifiers(procs, dpy, fmt, format)?;
+            let (modifiers, external_only) = unsafe { query_modifiers(procs, dpy, fmt, format)? };
             res.insert(
                 format.drm,
                 EglFormat {
@@ -349,32 +351,38 @@ unsafe fn query_modifiers(
     let mut mods = vec![];
     let mut ext_only = vec![];
     let mut num = 0;
-    let res = procs.eglQueryDmaBufModifiersEXT(
-        dpy,
-        gl_format,
-        num,
-        ptr::null_mut(),
-        ptr::null_mut(),
-        &mut num,
-    );
+    let res = unsafe {
+        procs.eglQueryDmaBufModifiersEXT(
+            dpy,
+            gl_format,
+            num,
+            ptr::null_mut(),
+            ptr::null_mut(),
+            &mut num,
+        )
+    };
     if res != EGL_TRUE {
         return Err(RenderError::QueryDmaBufModifiers);
     }
     mods.reserve_exact(num as usize);
     ext_only.reserve_exact(num as usize);
-    let res = procs.eglQueryDmaBufModifiersEXT(
-        dpy,
-        gl_format,
-        num,
-        mods.as_mut_ptr(),
-        ext_only.as_mut_ptr(),
-        &mut num,
-    );
+    let res = unsafe {
+        procs.eglQueryDmaBufModifiersEXT(
+            dpy,
+            gl_format,
+            num,
+            mods.as_mut_ptr(),
+            ext_only.as_mut_ptr(),
+            &mut num,
+        )
+    };
     if res != EGL_TRUE {
         return Err(RenderError::QueryDmaBufModifiers);
     }
-    mods.set_len(num as usize);
-    ext_only.set_len(num as usize);
+    unsafe {
+        mods.set_len(num as usize);
+        ext_only.set_len(num as usize);
+    }
     let mut res = IndexMap::new();
     for (modifier, ext_only) in mods.iter().copied().zip(ext_only.iter().copied()) {
         res.insert(
diff --git a/src/gfx_apis/gl/ext.rs b/src/gfx_apis/gl/ext.rs
index 6967b4cd..7eaa2699 100644
--- a/src/gfx_apis/gl/ext.rs
+++ b/src/gfx_apis/gl/ext.rs
@@ -19,7 +19,7 @@ unsafe fn get_extensions(ext: *const c::c_char) -> Option<AHashSet<String>> {
         return None;
     }
     let mut res = AHashSet::new();
-    let ext = CStr::from_ptr(ext).to_bytes();
+    let ext = unsafe { CStr::from_ptr(ext).to_bytes() };
     for part in ext.split_str(" ") {
         let name = part.trim();
         if name.len() > 0 {
@@ -32,8 +32,10 @@ unsafe fn get_extensions(ext: *const c::c_char) -> Option<AHashSet<String>> {
 }
 
 unsafe fn get_dpy_extensions(dpy: EGLDisplay) -> Option<AHashSet<String>> {
-    let ext = (EGL.as_ref()?.eglQueryString)(dpy, EGL_EXTENSIONS);
-    get_extensions(ext)
+    unsafe {
+        let ext = (EGL.as_ref()?.eglQueryString)(dpy, EGL_EXTENSIONS);
+        get_extensions(ext)
+    }
 }
 
 fn get_typed_ext<T>(exts: &AHashSet<String>, mut base: T, map: &[(&str, T)]) -> T
@@ -103,7 +105,7 @@ pub(crate) unsafe fn get_display_ext(dpy: EGLDisplay) -> DisplayExt {
         ("EGL_KHR_wait_sync", KHR_WAIT_SYNC),
         ("EGL_ANDROID_native_fence_sync", ANDROID_NATIVE_FENCE_SYNC),
     ];
-    match get_dpy_extensions(dpy) {
+    match unsafe { get_dpy_extensions(dpy) } {
         Some(exts) => get_typed_ext(&exts, DisplayExt::none(), &map),
         _ => DisplayExt::none(),
     }
diff --git a/src/gfx_apis/gl/gl/program.rs b/src/gfx_apis/gl/gl/program.rs
index 3514514f..1e87f2a4 100644
--- a/src/gfx_apis/gl/gl/program.rs
+++ b/src/gfx_apis/gl/gl/program.rs
@@ -21,41 +21,45 @@ impl GlProgram {
         vert: &str,
         frag: &str,
     ) -> Result<Self, RenderError> {
-        let vert = GlShader::compile(ctx, GL_VERTEX_SHADER, vert)?;
-        let frag = GlShader::compile(ctx, GL_FRAGMENT_SHADER, frag)?;
-        Self::link(&vert, &frag)
+        unsafe {
+            let vert = GlShader::compile(ctx, GL_VERTEX_SHADER, vert)?;
+            let frag = GlShader::compile(ctx, GL_FRAGMENT_SHADER, frag)?;
+            Self::link(&vert, &frag)
+        }
     }
 
     pub(in crate::gfx_apis::gl) unsafe fn link(
         vert: &GlShader,
         frag: &GlShader,
     ) -> Result<Self, RenderError> {
-        let gles = vert.ctx.dpy.gles;
-        let res = GlProgram {
-            ctx: vert.ctx.clone(),
-            prog: (gles.glCreateProgram)(),
-        };
-        (gles.glAttachShader)(res.prog, vert.shader);
-        (gles.glAttachShader)(res.prog, frag.shader);
-        (gles.glLinkProgram)(res.prog);
-        (gles.glDetachShader)(res.prog, vert.shader);
-        (gles.glDetachShader)(res.prog, frag.shader);
+        unsafe {
+            let gles = vert.ctx.dpy.gles;
+            let res = GlProgram {
+                ctx: vert.ctx.clone(),
+                prog: (gles.glCreateProgram)(),
+            };
+            (gles.glAttachShader)(res.prog, vert.shader);
+            (gles.glAttachShader)(res.prog, frag.shader);
+            (gles.glLinkProgram)(res.prog);
+            (gles.glDetachShader)(res.prog, vert.shader);
+            (gles.glDetachShader)(res.prog, frag.shader);
 
-        let mut ok = 0;
-        (gles.glGetProgramiv)(res.prog, GL_LINK_STATUS, &mut ok);
-        if ok == GL_FALSE as GLint {
-            return Err(RenderError::ProgramLink);
+            let mut ok = 0;
+            (gles.glGetProgramiv)(res.prog, GL_LINK_STATUS, &mut ok);
+            if ok == GL_FALSE as GLint {
+                return Err(RenderError::ProgramLink);
+            }
+
+            Ok(res)
         }
-
-        Ok(res)
     }
 
     pub unsafe fn get_uniform_location(&self, name: &CStr) -> GLint {
-        (self.ctx.dpy.gles.glGetUniformLocation)(self.prog, name.as_ptr() as _)
+        unsafe { (self.ctx.dpy.gles.glGetUniformLocation)(self.prog, name.as_ptr() as _) }
     }
 
     pub unsafe fn get_attrib_location(&self, name: &CStr) -> GLint {
-        (self.ctx.dpy.gles.glGetAttribLocation)(self.prog, name.as_ptr() as _)
+        unsafe { (self.ctx.dpy.gles.glGetAttribLocation)(self.prog, name.as_ptr() as _) }
     }
 }
 
diff --git a/src/gfx_apis/gl/gl/render_buffer.rs b/src/gfx_apis/gl/gl/render_buffer.rs
index 92eec843..5513794b 100644
--- a/src/gfx_apis/gl/gl/render_buffer.rs
+++ b/src/gfx_apis/gl/gl/render_buffer.rs
@@ -39,10 +39,17 @@ impl GlRenderBuffer {
         };
         let gles = &ctx.dpy.gles;
         let mut rbo = 0;
-        (gles.glGenRenderbuffers)(1, &mut rbo);
-        (gles.glBindRenderbuffer)(GL_RENDERBUFFER, rbo);
-        (gles.glRenderbufferStorage)(GL_RENDERBUFFER, shm_info.gl_internal_format, width, height);
-        (gles.glBindRenderbuffer)(GL_RENDERBUFFER, 0);
+        unsafe {
+            (gles.glGenRenderbuffers)(1, &mut rbo);
+            (gles.glBindRenderbuffer)(GL_RENDERBUFFER, rbo);
+            (gles.glRenderbufferStorage)(
+                GL_RENDERBUFFER,
+                shm_info.gl_internal_format,
+                width,
+                height,
+            );
+            (gles.glBindRenderbuffer)(GL_RENDERBUFFER, 0);
+        }
         Ok(Rc::new(GlRenderBuffer {
             _img: None,
             ctx: ctx.clone(),
@@ -63,12 +70,14 @@ impl GlRenderBuffer {
         }
         let gles = ctx.dpy.gles;
         let mut rbo = 0;
-        (gles.glGenRenderbuffers)(1, &mut rbo);
-        (gles.glBindRenderbuffer)(GL_RENDERBUFFER, rbo);
-        ctx.dpy
-            .procs
-            .glEGLImageTargetRenderbufferStorageOES(GL_RENDERBUFFER, GLeglImageOES(img.img.0));
-        (gles.glBindRenderbuffer)(GL_RENDERBUFFER, 0);
+        unsafe {
+            (gles.glGenRenderbuffers)(1, &mut rbo);
+            (gles.glBindRenderbuffer)(GL_RENDERBUFFER, rbo);
+            ctx.dpy
+                .procs
+                .glEGLImageTargetRenderbufferStorageOES(GL_RENDERBUFFER, GLeglImageOES(img.img.0));
+            (gles.glBindRenderbuffer)(GL_RENDERBUFFER, 0);
+        }
         Ok(Rc::new(GlRenderBuffer {
             _img: Some(img.clone()),
             ctx: ctx.clone(),
@@ -85,28 +94,30 @@ impl GlRenderBuffer {
     ) -> Result<GlFrameBuffer, RenderError> {
         let gles = self.ctx.dpy.gles;
         let mut fbo = 0;
-        (gles.glGenFramebuffers)(1, &mut fbo);
-        (gles.glBindFramebuffer)(GL_FRAMEBUFFER, fbo);
-        (gles.glFramebufferRenderbuffer)(
-            GL_FRAMEBUFFER,
-            GL_COLOR_ATTACHMENT0,
-            GL_RENDERBUFFER,
-            self.rbo,
-        );
-        let status = (gles.glCheckFramebufferStatus)(GL_FRAMEBUFFER);
-        (gles.glBindFramebuffer)(GL_FRAMEBUFFER, 0);
-        let fb = GlFrameBuffer {
-            rb: self.clone(),
-            _tex: None,
-            ctx: self.ctx.clone(),
-            fbo,
-            width: self.width,
-            height: self.height,
-        };
-        if status != GL_FRAMEBUFFER_COMPLETE {
-            return Err(RenderError::CreateFramebuffer);
+        unsafe {
+            (gles.glGenFramebuffers)(1, &mut fbo);
+            (gles.glBindFramebuffer)(GL_FRAMEBUFFER, fbo);
+            (gles.glFramebufferRenderbuffer)(
+                GL_FRAMEBUFFER,
+                GL_COLOR_ATTACHMENT0,
+                GL_RENDERBUFFER,
+                self.rbo,
+            );
+            let status = (gles.glCheckFramebufferStatus)(GL_FRAMEBUFFER);
+            (gles.glBindFramebuffer)(GL_FRAMEBUFFER, 0);
+            let fb = GlFrameBuffer {
+                rb: self.clone(),
+                _tex: None,
+                ctx: self.ctx.clone(),
+                fbo,
+                width: self.width,
+                height: self.height,
+            };
+            if status != GL_FRAMEBUFFER_COMPLETE {
+                return Err(RenderError::CreateFramebuffer);
+            }
+            Ok(fb)
         }
-        Ok(fb)
     }
 }
 
diff --git a/src/gfx_apis/gl/gl/shader.rs b/src/gfx_apis/gl/gl/shader.rs
index 9a13de48..3812cb56 100644
--- a/src/gfx_apis/gl/gl/shader.rs
+++ b/src/gfx_apis/gl/gl/shader.rs
@@ -20,17 +20,21 @@ impl GlShader {
         src: &str,
     ) -> Result<Self, RenderError> {
         let gles = ctx.dpy.gles;
-        let shader = (gles.glCreateShader)(ty);
+        let shader = unsafe { (gles.glCreateShader)(ty) };
         let res = GlShader {
             ctx: ctx.clone(),
             shader,
         };
         let len = src.len() as _;
-        (gles.glShaderSource)(shader, 1, &(src.as_ptr() as _), &len);
-        (gles.glCompileShader)(shader);
+        unsafe {
+            (gles.glShaderSource)(shader, 1, &(src.as_ptr() as _), &len);
+            (gles.glCompileShader)(shader);
+        }
 
         let mut ok = 0;
-        (gles.glGetShaderiv)(shader, GL_COMPILE_STATUS, &mut ok);
+        unsafe {
+            (gles.glGetShaderiv)(shader, GL_COMPILE_STATUS, &mut ok);
+        }
         if ok == GL_FALSE as GLint {
             return Err(RenderError::ShaderCompileFailed);
         }
diff --git a/src/gfx_apis/gl/renderer/context.rs b/src/gfx_apis/gl/renderer/context.rs
index 34a7ccd1..5bbed160 100644
--- a/src/gfx_apis/gl/renderer/context.rs
+++ b/src/gfx_apis/gl/renderer/context.rs
@@ -44,16 +44,18 @@ pub(crate) struct TexProg {
 
 impl TexProg {
     unsafe fn from(prog: GlProgram, alpha_multiplier: bool) -> Self {
-        let alpha = match alpha_multiplier {
-            true => prog.get_uniform_location(c"alpha"),
-            false => 0,
-        };
-        Self {
-            pos: prog.get_attrib_location(c"pos"),
-            texcoord: prog.get_attrib_location(c"texcoord"),
-            tex: prog.get_uniform_location(c"tex"),
-            alpha,
-            prog,
+        unsafe {
+            let alpha = match alpha_multiplier {
+                true => prog.get_uniform_location(c"alpha"),
+                false => 0,
+            };
+            Self {
+                pos: prog.get_attrib_location(c"pos"),
+                texcoord: prog.get_attrib_location(c"texcoord"),
+                tex: prog.get_uniform_location(c"tex"),
+                alpha,
+                prog,
+            }
         }
     }
 }
@@ -129,8 +131,10 @@ impl GlRenderContext {
                     tex_frac_src.push_str("#define ALPHA\n");
                 }
                 tex_frac_src.push_str(tex_frag);
-                let prog = GlProgram::from_shaders(ctx, tex_vert, &tex_frac_src)?;
-                Ok::<_, RenderError>(TexProg::from(prog, alpha_multiplier))
+                unsafe {
+                    let prog = GlProgram::from_shaders(ctx, tex_vert, &tex_frac_src)?;
+                    Ok::<_, RenderError>(TexProg::from(prog, alpha_multiplier))
+                }
             };
             Ok::<_, RenderError>(enum_map! {
                 TexCopyType::Identity => enum_map! {
@@ -149,11 +153,13 @@ impl GlRenderContext {
         } else {
             None
         };
-        let fill_prog = GlProgram::from_shaders(
-            ctx,
-            include_str!("../shaders/fill.vert.glsl"),
-            include_str!("../shaders/fill.frag.glsl"),
-        )?;
+        let fill_prog = unsafe {
+            GlProgram::from_shaders(
+                ctx,
+                include_str!("../shaders/fill.vert.glsl"),
+                include_str!("../shaders/fill.frag.glsl"),
+            )?
+        };
         Ok(Self {
             ctx: ctx.clone(),
             gbm: ctx.dpy.gbm.clone(),
@@ -164,8 +170,8 @@ impl GlRenderContext {
             tex_internal,
             tex_external,
 
-            fill_prog_pos: fill_prog.get_attrib_location(c"pos"),
-            fill_prog_color: fill_prog.get_uniform_location(c"color"),
+            fill_prog_pos: unsafe { fill_prog.get_attrib_location(c"pos") },
+            fill_prog_color: unsafe { fill_prog.get_uniform_location(c"color") },
             fill_prog,
 
             gl_state: Default::default(),
diff --git a/src/gfx_apis/vulkan/allocator.rs b/src/gfx_apis/vulkan/allocator.rs
index 536e0667..bdc555ec 100644
--- a/src/gfx_apis/vulkan/allocator.rs
+++ b/src/gfx_apis/vulkan/allocator.rs
@@ -67,7 +67,9 @@ impl VulkanAllocation {
     ) {
         allocator.total.fetch_sub(self.size);
         let block = self.block.take().unwrap();
-        do_free(gpu, &device.device, block, self.mem);
+        unsafe {
+            do_free(gpu, &device.device, block, self.mem);
+        }
     }
 }
 
@@ -363,12 +365,14 @@ unsafe fn do_free(
     mut block: MemoryBlock<DeviceMemory>,
     ptr: Option<*mut u8>,
 ) {
-    let device = AshMemoryDevice::wrap(device);
-    if let Some(_ptr) = ptr {
-        // log::info!("free = {:?} - {:?} ({})", ptr, ptr.add(block.size() as usize), block.size());
-        block.unmap(device);
+    unsafe {
+        let device = AshMemoryDevice::wrap(device);
+        if let Some(_ptr) = ptr {
+            // log::info!("free = {:?} - {:?} ({})", ptr, ptr.add(block.size() as usize), block.size());
+            block.unmap(device);
+        }
+        gpu.dealloc(device, block);
     }
-    gpu.dealloc(device, block);
 }
 
 impl Drop for UnsyncAllocatorStorage {
diff --git a/src/gfx_apis/vulkan/bo_allocator.rs b/src/gfx_apis/vulkan/bo_allocator.rs
index f9ae381d..5b083dcb 100644
--- a/src/gfx_apis/vulkan/bo_allocator.rs
+++ b/src/gfx_apis/vulkan/bo_allocator.rs
@@ -671,7 +671,7 @@ impl Drop for VulkanBoMapping {
 
 impl MappedBuffer for VulkanBoMapping {
     unsafe fn data(&self) -> &[u8] {
-        &*self.data
+        unsafe { &*self.data }
     }
 
     fn data_ptr(&self) -> *mut u8 {
diff --git a/src/gfx_apis/vulkan/instance.rs b/src/gfx_apis/vulkan/instance.rs
index bb39f3c3..ddbe5dee 100644
--- a/src/gfx_apis/vulkan/instance.rs
+++ b/src/gfx_apis/vulkan/instance.rs
@@ -190,12 +190,12 @@ unsafe extern "system" fn debug_callback(
         DebugUtilsMessageSeverityFlagsEXT::VERBOSE => Level::Trace,
         _ => Level::Warn,
     };
-    let data = &*p_callback_data;
-    let message = Ustr::from_ptr(data.p_message);
+    let data = unsafe { &*p_callback_data };
+    let message = unsafe { Ustr::from_ptr(data.p_message) };
     let message_id_name = if data.p_message_id_name.is_null() {
         ustr!("<null>")
     } else {
-        Ustr::from_ptr(data.p_message_id_name)
+        unsafe { Ustr::from_ptr(data.p_message_id_name) }
     };
     log::log!(
         Level::Info,
diff --git a/src/libinput.rs b/src/libinput.rs
index 9cf6090f..44512f3c 100644
--- a/src/libinput.rs
+++ b/src/libinput.rs
@@ -41,12 +41,14 @@ unsafe extern "C" fn open_restricted(
     _flags: c::c_int,
     user_data: *mut c::c_void,
 ) -> c::c_int {
-    let ud = (user_data as *const UserData).deref();
-    match ud.adapter.open(CStr::from_ptr(path)) {
-        Ok(f) => f.unwrap(),
-        Err(e) => {
-            log::error!("Could not open device for libinput: {}", ErrorFmt(e));
-            -1
+    unsafe {
+        let ud = (user_data as *const UserData).deref();
+        match ud.adapter.open(CStr::from_ptr(path)) {
+            Ok(f) => f.unwrap(),
+            Err(e) => {
+                log::error!("Could not open device for libinput: {}", ErrorFmt(e));
+                -1
+            }
         }
     }
 }
@@ -173,7 +175,7 @@ unsafe extern "C" fn jay_libinput_log_handler(
     line: *const c::c_char,
 ) {
     assert!(line.is_not_null());
-    let str = CStr::from_ptr(line);
+    let str = unsafe { CStr::from_ptr(line) };
     let priority = match LogPriority(priority as _) {
         LIBINPUT_LOG_PRIORITY_DEBUG => log::Level::Debug,
         LIBINPUT_LOG_PRIORITY_INFO => log::Level::Info,
diff --git a/src/main.rs b/src/main.rs
index a8b41234..9fd5c2e0 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -37,7 +37,7 @@
     clippy::unnecessary_cast,
     clippy::manual_flatten
 )]
-#![warn(clippy::allow_attributes)]
+#![warn(clippy::allow_attributes, unsafe_op_in_unsafe_fn)]
 
 #[macro_use]
 mod macros;
diff --git a/src/pipewire/pw_mem.rs b/src/pipewire/pw_mem.rs
index c9040868..237b234c 100644
--- a/src/pipewire/pw_mem.rs
+++ b/src/pipewire/pw_mem.rs
@@ -88,21 +88,23 @@ impl PwMemMap {
     #[expect(dead_code)]
     pub unsafe fn read<T: Pod>(&self) -> &T {
         self.check::<T>(0);
-        (self.map.ptr.cast::<u8>().add(self.range.start) as *const T).deref()
+        unsafe { (self.map.ptr.cast::<u8>().add(self.range.start) as *const T).deref() }
     }
 
     #[expect(dead_code)]
     pub unsafe fn write<T: Pod>(&self) -> &mut T {
         self.check::<T>(0);
-        (self.map.ptr.cast::<u8>().add(self.range.start) as *mut T).deref_mut()
+        unsafe { (self.map.ptr.cast::<u8>().add(self.range.start) as *mut T).deref_mut() }
     }
 
     #[expect(dead_code)]
     pub unsafe fn bytes_mut(&self) -> &mut [u8] {
-        std::slice::from_raw_parts_mut(
-            self.map.ptr.cast::<u8>().add(self.range.start) as _,
-            self.range.len(),
-        )
+        unsafe {
+            std::slice::from_raw_parts_mut(
+                self.map.ptr.cast::<u8>().add(self.range.start) as _,
+                self.range.len(),
+            )
+        }
     }
 
     fn check<T>(&self, offset: usize) {
@@ -136,11 +138,11 @@ impl PwMemMap {
 
 impl<T: Pod> PwMemTyped<T> {
     pub unsafe fn read(&self) -> &T {
-        (self.mem.map.ptr.cast::<u8>().add(self.offset) as *const T).deref()
+        unsafe { (self.mem.map.ptr.cast::<u8>().add(self.offset) as *const T).deref() }
     }
 
     pub unsafe fn write(&self) -> &mut T {
-        (self.mem.map.ptr.cast::<u8>().add(self.offset) as *mut T).deref_mut()
+        unsafe { (self.mem.map.ptr.cast::<u8>().add(self.offset) as *mut T).deref_mut() }
     }
 }
 
diff --git a/src/udmabuf.rs b/src/udmabuf.rs
index d8766e11..8a25547d 100644
--- a/src/udmabuf.rs
+++ b/src/udmabuf.rs
@@ -241,7 +241,7 @@ impl Drop for UdmabufMap {
 
 impl MappedBuffer for UdmabufMap {
     unsafe fn data(&self) -> &[u8] {
-        &*self.data
+        unsafe { &*self.data }
     }
 
     fn data_ptr(&self) -> *mut u8 {
diff --git a/src/utils/linkedlist.rs b/src/utils/linkedlist.rs
index 35974dde..0fde4b90 100644
--- a/src/utils/linkedlist.rs
+++ b/src/utils/linkedlist.rs
@@ -296,8 +296,10 @@ struct NodeData<T> {
 }
 
 unsafe fn dec_ref_count<T>(slf: NonNull<NodeData<T>>, n: usize) {
-    if slf.as_ref().rc.fetch_sub(n) == n {
-        drop(Box::from_raw(slf.as_ptr()));
+    unsafe {
+        if slf.as_ref().rc.fetch_sub(n) == n {
+            drop(Box::from_raw(slf.as_ptr()));
+        }
     }
 }
 
@@ -337,55 +339,63 @@ impl<T> LinkedNode<T> {
 }
 
 unsafe fn prepend_existing<T>(data: NonNull<NodeData<T>>, t: &NodeRef<T>) {
-    let dref = data.as_ref();
-    let tref = t.data.as_ref();
-    if tref.rc.get() < LINKED_NODE_REF_COUNT {
-        log::error!("Trying to prepend a node whose linked node has already been dropped");
-        return;
+    unsafe {
+        let dref = data.as_ref();
+        let tref = t.data.as_ref();
+        if tref.rc.get() < LINKED_NODE_REF_COUNT {
+            log::error!("Trying to prepend a node whose linked node has already been dropped");
+            return;
+        }
+        t.detach();
+        tref.prev.set(dref.prev.get());
+        tref.next.set(data);
+        dref.prev.get().as_ref().next.set(t.data);
+        dref.prev.set(t.data);
     }
-    t.detach();
-    tref.prev.set(dref.prev.get());
-    tref.next.set(data);
-    dref.prev.get().as_ref().next.set(t.data);
-    dref.prev.set(t.data);
 }
 
 unsafe fn prepend<T>(data: NonNull<NodeData<T>>, t: T) -> LinkedNode<T> {
-    let dref = data.as_ref();
-    let node = NonNull::new_unchecked(Box::into_raw(Box::new(NodeData {
-        rc: NumCell::new(LINKED_NODE_REF_COUNT),
-        prev: Cell::new(dref.prev.get()),
-        next: Cell::new(data),
-        data: Some(t),
-    })));
-    dref.prev.get().as_ref().next.set(node);
-    dref.prev.set(node);
-    LinkedNode { data: node }
+    unsafe {
+        let dref = data.as_ref();
+        let node = NonNull::new_unchecked(Box::into_raw(Box::new(NodeData {
+            rc: NumCell::new(LINKED_NODE_REF_COUNT),
+            prev: Cell::new(dref.prev.get()),
+            next: Cell::new(data),
+            data: Some(t),
+        })));
+        dref.prev.get().as_ref().next.set(node);
+        dref.prev.set(node);
+        LinkedNode { data: node }
+    }
 }
 
 unsafe fn append_existing<T>(data: NonNull<NodeData<T>>, t: &NodeRef<T>) {
-    let dref = data.as_ref();
-    let tref = t.data.as_ref();
-    if tref.rc.get() < LINKED_NODE_REF_COUNT {
-        log::error!("Trying to append a node whose linked node has already been dropped");
-        return;
+    unsafe {
+        let dref = data.as_ref();
+        let tref = t.data.as_ref();
+        if tref.rc.get() < LINKED_NODE_REF_COUNT {
+            log::error!("Trying to append a node whose linked node has already been dropped");
+            return;
+        }
+        t.detach();
+        tref.prev.set(data);
+        tref.next.set(dref.next.get());
+        dref.next.get().as_ref().prev.set(t.data);
+        dref.next.set(t.data);
     }
-    t.detach();
-    tref.prev.set(data);
-    tref.next.set(dref.next.get());
-    dref.next.get().as_ref().prev.set(t.data);
-    dref.next.set(t.data);
 }
 
 unsafe fn append<T>(data: NonNull<NodeData<T>>, t: T) -> LinkedNode<T> {
-    let dref = data.as_ref();
-    let node = NonNull::new_unchecked(Box::into_raw(Box::new(NodeData {
-        rc: NumCell::new(LINKED_NODE_REF_COUNT),
-        prev: Cell::new(data),
-        next: Cell::new(dref.next.get()),
-        data: Some(t),
-    })));
-    dref.next.get().as_ref().prev.set(node);
-    dref.next.set(node);
-    LinkedNode { data: node }
+    unsafe {
+        let dref = data.as_ref();
+        let node = NonNull::new_unchecked(Box::into_raw(Box::new(NodeData {
+            rc: NumCell::new(LINKED_NODE_REF_COUNT),
+            prev: Cell::new(data),
+            next: Cell::new(dref.next.get()),
+            data: Some(t),
+        })));
+        dref.next.get().as_ref().prev.set(node);
+        dref.next.set(node);
+        LinkedNode { data: node }
+    }
 }
diff --git a/src/utils/ptr_ext.rs b/src/utils/ptr_ext.rs
index 31e73ec2..4acb415e 100644
--- a/src/utils/ptr_ext.rs
+++ b/src/utils/ptr_ext.rs
@@ -9,20 +9,20 @@ pub trait MutPtrExt<T: ?Sized> {
 impl<T: ?Sized> PtrExt<T> for *const T {
     #[inline(always)]
     unsafe fn deref<'a>(self) -> &'a T {
-        &*self
+        unsafe { &*self }
     }
 }
 
 impl<T: ?Sized> PtrExt<T> for *mut T {
     #[inline(always)]
     unsafe fn deref<'a>(self) -> &'a T {
-        &*self
+        unsafe { &*self }
     }
 }
 
 impl<T: ?Sized> MutPtrExt<T> for *mut T {
     #[inline(always)]
     unsafe fn deref_mut<'a>(self) -> &'a mut T {
-        &mut *self
+        unsafe { &mut *self }
     }
 }
diff --git a/src/utils/vecstorage.rs b/src/utils/vecstorage.rs
index 5b535850..751638e6 100644
--- a/src/utils/vecstorage.rs
+++ b/src/utils/vecstorage.rs
@@ -35,7 +35,7 @@ impl<T> VecStorage<T> {
     }
 
     unsafe fn to_vector<U>(&mut self) -> Vec<U> {
-        Vec::from_raw_parts(self.ptr as _, 0, self.cap)
+        unsafe { Vec::from_raw_parts(self.ptr as _, 0, self.cap) }
     }
 }
 
diff --git a/src/video/drm/sys.rs b/src/video/drm/sys.rs
index ed6dcce0..7e58c234 100644
--- a/src/video/drm/sys.rs
+++ b/src/video/drm/sys.rs
@@ -23,7 +23,7 @@ use {
 pub unsafe fn ioctl<T>(fd: c::c_int, request: c::c_ulong, t: &mut T) -> Result<c::c_int, OsError> {
     let mut ret;
     loop {
-        ret = c::ioctl(fd, request, &mut *t);
+        ret = unsafe { c::ioctl(fd, request, &mut *t) };
         if ret != -1 {
             return Ok(ret);
         }
diff --git a/src/video/gbm.rs b/src/video/gbm.rs
index 6fbee1d1..09caf304 100644
--- a/src/video/gbm.rs
+++ b/src/video/gbm.rs
@@ -158,7 +158,7 @@ pub struct GbmBoMap {
 
 impl MappedBuffer for GbmBoMap {
     unsafe fn data(&self) -> &[u8] {
-        &*self.data
+        unsafe { &*self.data }
     }
 
     fn data_ptr(&self) -> *mut u8 {
@@ -171,36 +171,38 @@ impl MappedBuffer for GbmBoMap {
 }
 
 unsafe fn export_bo(dmabuf_ids: &DmaBufIds, bo: *mut Bo) -> Result<DmaBuf, GbmError> {
-    Ok(DmaBuf {
-        id: dmabuf_ids.next(),
-        width: gbm_bo_get_width(bo) as _,
-        height: gbm_bo_get_height(bo) as _,
-        modifier: gbm_bo_get_modifier(bo),
-        format: {
-            let format = gbm_bo_get_format(bo);
-            match formats().get(&format).copied() {
-                Some(f) => f,
-                _ => return Err(GbmError::UnknownFormat),
-            }
-        },
-        planes: {
-            let mut planes = PlaneVec::new();
-            for plane in 0..gbm_bo_get_plane_count(bo) {
-                let offset = gbm_bo_get_offset(bo, plane);
-                let stride = gbm_bo_get_stride_for_plane(bo, plane);
-                let fd = gbm_bo_get_fd_for_plane(bo, plane);
-                if fd < 0 {
-                    return Err(GbmError::DrmFd);
+    unsafe {
+        Ok(DmaBuf {
+            id: dmabuf_ids.next(),
+            width: gbm_bo_get_width(bo) as _,
+            height: gbm_bo_get_height(bo) as _,
+            modifier: gbm_bo_get_modifier(bo),
+            format: {
+                let format = gbm_bo_get_format(bo);
+                match formats().get(&format).copied() {
+                    Some(f) => f,
+                    _ => return Err(GbmError::UnknownFormat),
                 }
-                planes.push(DmaBufPlane {
-                    offset,
-                    stride,
-                    fd: Rc::new(OwnedFd::new(fd)),
-                })
-            }
-            planes
-        },
-    })
+            },
+            planes: {
+                let mut planes = PlaneVec::new();
+                for plane in 0..gbm_bo_get_plane_count(bo) {
+                    let offset = gbm_bo_get_offset(bo, plane);
+                    let stride = gbm_bo_get_stride_for_plane(bo, plane);
+                    let fd = gbm_bo_get_fd_for_plane(bo, plane);
+                    if fd < 0 {
+                        return Err(GbmError::DrmFd);
+                    }
+                    planes.push(DmaBufPlane {
+                        offset,
+                        stride,
+                        fd: Rc::new(OwnedFd::new(fd)),
+                    })
+                }
+                planes
+            },
+        })
+    }
 }
 
 impl GbmDevice {
diff --git a/src/xkbcommon.rs b/src/xkbcommon.rs
index 0e14b3e2..9e8ce87c 100644
--- a/src/xkbcommon.rs
+++ b/src/xkbcommon.rs
@@ -415,7 +415,7 @@ unsafe extern "C" fn jay_xkbcommon_log_handler(
     line: *const c::c_char,
 ) {
     assert!(line.is_not_null());
-    let buf = CStr::from_ptr(line);
+    let buf = unsafe { CStr::from_ptr(line) };
     let level = match XkbLogLevel(level) {
         XKB_LOG_LEVEL_CRITICAL | XKB_LOG_LEVEL_ERROR => log::Level::Error,
         XKB_LOG_LEVEL_WARNING => log::Level::Warn,