diff --git a/aos/ipc_lib/aos_sync.cc b/aos/ipc_lib/aos_sync.cc
index 34d9489..39ea4c6 100644
--- a/aos/ipc_lib/aos_sync.cc
+++ b/aos/ipc_lib/aos_sync.cc
@@ -6,18 +6,19 @@
 #include "aos/ipc_lib/aos_sync.h"
 
 #include <linux/futex.h>
-#include <unistd.h>
-#include <sys/syscall.h>
-#include <errno.h>
-#include <stdint.h>
-#include <limits.h>
-#include <string.h>
-#include <inttypes.h>
-#include <sys/types.h>
-#include <stddef.h>
-#include <assert.h>
 #include <pthread.h>
 #include <sched.h>
+#include <sys/syscall.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <cassert>
+#include <cerrno>
+#include <cinttypes>
+#include <climits>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
 
 #ifdef AOS_SANITIZER_thread
 #include <sanitizer/tsan_interface_atomic.h>
@@ -27,16 +28,16 @@
 #include <type_traits>
 
 #include "absl/base/call_once.h"
-#include "glog/logging.h"
-
 #include "aos/macros.h"
 #include "aos/thread_local.h"
 #include "aos/util/compiler_memory_barrier.h"
+#include "glog/logging.h"
 
 using ::aos::linux_code::ipc_lib::FutexAccessorObserver;
 
-// This code was originally based on <https://www.akkadia.org/drepper/futex.pdf>,
-// but is has since evolved a lot. However, that still has useful information.
+// This code was originally based on
+// <https://www.akkadia.org/drepper/futex.pdf>, but is has since evolved a lot.
+// However, that still has useful information.
 //
 // Finding information about actually using futexes is really REALLY hard, so
 //   here's a list of the stuff that I've used:
@@ -171,7 +172,8 @@
 }
 
 inline int sys_futex_cmp_requeue_pi(aos_futex *addr1, int num_wake,
-    int num_requeue, aos_futex *m, uint32_t val) {
+                                    int num_requeue, aos_futex *m,
+                                    uint32_t val) {
 #if ARM_EABI_INLINE_SYSCALL
   register aos_futex *addr1_reg __asm__("r0") = addr1;
   register int op_reg __asm__("r1") = FUTEX_CMP_REQUEUE_PI;
@@ -196,8 +198,7 @@
 #endif
 }
 
-inline int sys_futex_wait_requeue_pi(aos_condition *addr1,
-                                     uint32_t start_val,
+inline int sys_futex_wait_requeue_pi(aos_condition *addr1, uint32_t start_val,
                                      const struct timespec *timeout,
                                      aos_futex *m) {
 #if ARM_EABI_INLINE_SYSCALL
@@ -463,8 +464,8 @@
     // We don't offset the head pointer, so be careful.
     return reinterpret_cast<aos_mutex *>(next);
   }
-  return reinterpret_cast<aos_mutex *>(
-      (next & ~kRobustListOr) - robust_list_offset);
+  return reinterpret_cast<aos_mutex *>((next & ~kRobustListOr) -
+                                       robust_list_offset);
 }
 
 // Sets up the robust list for each thread.
@@ -758,15 +759,11 @@
 
 }  // namespace
 
-int mutex_lock(aos_mutex *m) {
-  return mutex_get(m, true, NULL);
-}
+int mutex_lock(aos_mutex *m) { return mutex_get(m, true, NULL); }
 int mutex_lock_timeout(aos_mutex *m, const struct timespec *timeout) {
   return mutex_get(m, true, timeout);
 }
-int mutex_grab(aos_mutex *m) {
-  return mutex_get(m, false, NULL);
-}
+int mutex_grab(aos_mutex *m) { return mutex_get(m, false, NULL); }
 
 void mutex_unlock(aos_mutex *m) {
   RunObservers run_observers(m, true);
@@ -887,7 +884,7 @@
   if (ret != 0) {
     my_robust_list::robust_head.pending_next = 0;
     errno = -ret;
-    PLOG(FATAL)  << "FUTEX_UNLOCK_PI(" << &m->futex << ") failed";
+    PLOG(FATAL) << "FUTEX_UNLOCK_PI(" << &m->futex << ") failed";
   }
 }
 
@@ -1005,9 +1002,7 @@
   }
 }
 
-int futex_set(aos_futex *m) {
-  return futex_set_value(m, 1);
-}
+int futex_set(aos_futex *m) { return futex_set_value(m, 1); }
 
 int futex_unset(aos_futex *m) {
   return !__atomic_exchange_n(m, 0, __ATOMIC_SEQ_CST);
@@ -1036,9 +1031,7 @@
 
 // Returns true iff there are any mutexes locked by the current thread.
 // This is mainly useful for testing.
-bool HaveLockedMutexes() {
-  return my_robust_list::HaveLockedMutexes();
-}
+bool HaveLockedMutexes() { return my_robust_list::HaveLockedMutexes(); }
 
 }  // namespace ipc_lib
 }  // namespace linux_code
diff --git a/aos/ipc_lib/ipc_comparison.cc b/aos/ipc_lib/ipc_comparison.cc
index af1098d..fd1ff93 100644
--- a/aos/ipc_lib/ipc_comparison.cc
+++ b/aos/ipc_lib/ipc_comparison.cc
@@ -4,7 +4,6 @@
 #include <netinet/tcp.h>
 #include <pthread.h>
 #include <semaphore.h>
-#include <stdint.h>
 #include <sys/eventfd.h>
 #include <sys/msg.h>
 #include <sys/sem.h>
@@ -15,6 +14,7 @@
 
 #include <atomic>
 #include <chrono>
+#include <cstdint>
 #include <memory>
 #include <string>
 #include <thread>
diff --git a/aos/ipc_lib/ipc_stress_test.cc b/aos/ipc_lib/ipc_stress_test.cc
index aa5d9c5..5e72b6e 100644
--- a/aos/ipc_lib/ipc_stress_test.cc
+++ b/aos/ipc_lib/ipc_stress_test.cc
@@ -1,23 +1,23 @@
-#include <errno.h>
 #include <libgen.h>
-#include <stdio.h>
-#include <string.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
 
+#include <cerrno>
 #include <chrono>
+#include <cstdio>
+#include <cstring>
 #include <string>
 
 #include "aos/die.h"
+#include "aos/ipc_lib/core_lib.h"
 #include "aos/libc/aos_strsignal.h"
 #include "aos/libc/dirname.h"
 #include "aos/logging/logging.h"
 #include "aos/mutex/mutex.h"
+#include "aos/testing/test_shm.h"
 #include "aos/time/time.h"
 #include "aos/type_traits/type_traits.h"
-#include "aos/ipc_lib/core_lib.h"
-#include "aos/testing/test_shm.h"
 
 // This runs all of the IPC-related tests in a bunch of parallel processes for a
 // while and makes sure that they don't fail. It also captures the stdout and
@@ -42,17 +42,17 @@
 // Using --gtest_filter is a bad idea because it seems to result in a lot of
 // swapping which causes everything to be disk-bound (at least for me).
 static const size_t kTestMaxArgs = 10;
-static const char * kTests[][kTestMaxArgs] = {
-  {"queue_test"},
-  {"condition_test"},
-  {"mutex_test"},
-  {"raw_queue_test"},
+static const char *kTests[][kTestMaxArgs] = {
+    {"queue_test"},
+    {"condition_test"},
+    {"mutex_test"},
+    {"raw_queue_test"},
 };
 static const size_t kTestsLength = sizeof(kTests) / sizeof(kTests[0]);
 // These arguments get inserted before any per-test arguments.
 static const char *kDefaultArgs[] = {
-  "--gtest_repeat=30",
-  "--gtest_shuffle",
+    "--gtest_repeat=30",
+    "--gtest_shuffle",
 };
 
 // How many test processes to run at a time.
@@ -64,7 +64,7 @@
 // the child processes.
 struct Shared {
   Shared(const monotonic_clock::time_point stop_time)
-    : stop_time(stop_time), total_iterations(0) {}
+      : stop_time(stop_time), total_iterations(0) {}
 
   // Synchronizes access to stdout/stderr to avoid interleaving failure
   // messages.
@@ -84,8 +84,8 @@
               "it's going to get shared between forked processes");
 
 // Gets called after each child forks to run a test.
-void __attribute__((noreturn)) DoRunTest(
-    Shared *shared, const char *(*test)[kTestMaxArgs], int pipes[2]) {
+void __attribute__((noreturn))
+DoRunTest(Shared *shared, const char *(*test)[kTestMaxArgs], int pipes[2]) {
   if (close(pipes[0]) == -1) {
     PDie("close(%d) of read end of pipe failed", pipes[0]);
   }
@@ -173,15 +173,15 @@
     if (WIFEXITED(status)) {
       if (WEXITSTATUS(status) != 0) {
         MutexLocker sync(&shared->output_mutex);
-        fprintf(stderr, "Test %s exited with status %d. output:\n",
-                (*test)[0], WEXITSTATUS(status));
+        fprintf(stderr, "Test %s exited with status %d. output:\n", (*test)[0],
+                WEXITSTATUS(status));
         fputs(output.c_str(), stderr);
       }
     } else if (WIFSIGNALED(status)) {
       MutexLocker sync(&shared->output_mutex);
       fprintf(stderr, "Test %s terminated by signal %d: %s.\n", (*test)[0],
               WTERMSIG(status), aos_strsignal(WTERMSIG(status)));
-        fputs(output.c_str(), stderr);
+      fputs(output.c_str(), stderr);
     } else {
       CHECK(WIFSTOPPED(status));
       Die("Test %s was stopped.\n", (*test)[0]);
@@ -218,8 +218,8 @@
   Shared *shared = static_cast<Shared *>(shm_malloc(sizeof(Shared)));
   new (shared) Shared(monotonic_clock::now() + kTestTime);
 
-  if (asprintf(const_cast<char **>(&shared->path),
-               "%s/../tests", ::aos::libc::Dirname(argv[0]).c_str()) == -1) {
+  if (asprintf(const_cast<char **>(&shared->path), "%s/../tests",
+               ::aos::libc::Dirname(argv[0]).c_str()) == -1) {
     PDie("asprintf failed");
   }
 
@@ -251,6 +251,4 @@
 
 }  // namespace aos
 
-int main(int argc, char **argv) {
-  return ::aos::Main(argc, argv);
-}
+int main(int argc, char **argv) { return ::aos::Main(argc, argv); }
diff --git a/aos/ipc_lib/lockless_queue.h b/aos/ipc_lib/lockless_queue.h
index b0fc425..d6fb72f 100644
--- a/aos/ipc_lib/lockless_queue.h
+++ b/aos/ipc_lib/lockless_queue.h
@@ -1,14 +1,14 @@
 #ifndef AOS_IPC_LIB_LOCKLESS_QUEUE_H_
 #define AOS_IPC_LIB_LOCKLESS_QUEUE_H_
 
-#include <signal.h>
 #include <sys/signalfd.h>
 #include <sys/types.h>
+
+#include <csignal>
 #include <optional>
 #include <vector>
 
 #include "absl/types/span.h"
-
 #include "aos/ipc_lib/aos_sync.h"
 #include "aos/ipc_lib/data_alignment.h"
 #include "aos/ipc_lib/index.h"
diff --git a/aos/ipc_lib/lockless_queue_death_test.cc b/aos/ipc_lib/lockless_queue_death_test.cc
index ae780b8..3ed2ce5 100644
--- a/aos/ipc_lib/lockless_queue_death_test.cc
+++ b/aos/ipc_lib/lockless_queue_death_test.cc
@@ -1,18 +1,18 @@
-#include "aos/ipc_lib/lockless_queue.h"
-
 #include <dlfcn.h>
-#include <inttypes.h>
 #include <linux/futex.h>
 #include <sys/mman.h>
 #include <sys/syscall.h>
 #include <unistd.h>
 #include <wait.h>
+
 #include <chrono>
+#include <cinttypes>
 #include <functional>
 #include <memory>
 #include <thread>
 
 #include "aos/ipc_lib/aos_sync.h"
+#include "aos/ipc_lib/lockless_queue.h"
 #include "aos/ipc_lib/lockless_queue_memory.h"
 #include "aos/libc/aos_strsignal.h"
 #include "aos/realtime.h"
diff --git a/aos/ipc_lib/lockless_queue_test.cc b/aos/ipc_lib/lockless_queue_test.cc
index 57867e4..2b9f49c 100644
--- a/aos/ipc_lib/lockless_queue_test.cc
+++ b/aos/ipc_lib/lockless_queue_test.cc
@@ -1,11 +1,11 @@
 #include "aos/ipc_lib/lockless_queue.h"
 
-#include <inttypes.h>
-#include <signal.h>
 #include <unistd.h>
 #include <wait.h>
 
 #include <chrono>
+#include <cinttypes>
+#include <csignal>
 #include <memory>
 #include <random>
 #include <thread>
diff --git a/aos/ipc_lib/queue_racer.cc b/aos/ipc_lib/queue_racer.cc
index d14a638..b738805 100644
--- a/aos/ipc_lib/queue_racer.cc
+++ b/aos/ipc_lib/queue_racer.cc
@@ -1,8 +1,7 @@
 #include "aos/ipc_lib/queue_racer.h"
 
-#include <inttypes.h>
-#include <string.h>
-
+#include <cinttypes>
+#include <cstring>
 #include <limits>
 
 #include "aos/ipc_lib/event.h"
diff --git a/aos/ipc_lib/queue_racer.h b/aos/ipc_lib/queue_racer.h
index 7e92693..ea0238e 100644
--- a/aos/ipc_lib/queue_racer.h
+++ b/aos/ipc_lib/queue_racer.h
@@ -1,7 +1,7 @@
 #ifndef AOS_IPC_LIB_QUEUE_RACER_H_
 #define AOS_IPC_LIB_QUEUE_RACER_H_
 
-#include <string.h>
+#include <cstring>
 
 #include "aos/ipc_lib/lockless_queue.h"
 
diff --git a/aos/ipc_lib/shared_mem.cc b/aos/ipc_lib/shared_mem.cc
index 461e254..c91bbe9 100644
--- a/aos/ipc_lib/shared_mem.cc
+++ b/aos/ipc_lib/shared_mem.cc
@@ -1,14 +1,15 @@
 #include "aos/ipc_lib/shared_mem.h"
 
-#include <stdio.h>
-#include <string.h>
-#include <sys/mman.h>
 #include <fcntl.h>
-#include <unistd.h>
+#include <sys/mman.h>
 #include <sys/types.h>
-#include <errno.h>
-#include <stdlib.h>
-#include <assert.h>
+#include <unistd.h>
+
+#include <cassert>
+#include <cerrno>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
 
 #include "aos/ipc_lib/aos_sync.h"
 #include "aos/ipc_lib/core_lib.h"
@@ -21,7 +22,7 @@
 #define SIZEOFSHMSEG (4096 * 0x800)
 
 void init_shared_mem_core(aos_shm_core *shm_core) {
-  memset(&shm_core->time_offset, 0 , sizeof(shm_core->time_offset));
+  memset(&shm_core->time_offset, 0, sizeof(shm_core->time_offset));
   memset(&shm_core->msg_alloc_lock, 0, sizeof(shm_core->msg_alloc_lock));
   shm_core->queues.pointer = NULL;
   memset(&shm_core->queues.lock, 0, sizeof(shm_core->queues.lock));
@@ -30,9 +31,8 @@
 }
 
 ptrdiff_t aos_core_get_mem_usage(void) {
-  return global_core->size -
-      ((ptrdiff_t)global_core->mem_struct->msg_alloc -
-       (ptrdiff_t)global_core->mem_struct);
+  return global_core->size - ((ptrdiff_t)global_core->mem_struct->msg_alloc -
+                              (ptrdiff_t)global_core->mem_struct);
 }
 
 struct aos_core *global_core = NULL;
diff --git a/aos/ipc_lib/signal_stress.cc b/aos/ipc_lib/signal_stress.cc
index 2f2ca41..57a4158 100644
--- a/aos/ipc_lib/signal_stress.cc
+++ b/aos/ipc_lib/signal_stress.cc
@@ -1,8 +1,7 @@
-#include "gflags/gflags.h"
-
-#include <signal.h>
 #include <sys/signalfd.h>
+
 #include <chrono>
+#include <csignal>
 #include <random>
 #include <thread>
 
@@ -13,6 +12,7 @@
 #include "aos/logging/logging.h"
 #include "aos/realtime.h"
 #include "aos/time/time.h"
+#include "gflags/gflags.h"
 
 // This is a demo program which uses Real-Time posix signals to communicate.
 // It measures both latency of a random timer thread, and latency of the
diff --git a/aos/ipc_lib/signalfd.cc b/aos/ipc_lib/signalfd.cc
index 3689b7e..f23d0be 100644
--- a/aos/ipc_lib/signalfd.cc
+++ b/aos/ipc_lib/signalfd.cc
@@ -1,7 +1,8 @@
 #include "aos/ipc_lib/signalfd.h"
 
-#include <signal.h>
 #include <sys/types.h>
+
+#include <csignal>
 #if __has_feature(memory_sanitizer)
 #include <sanitizer/msan_interface.h>
 #endif