diff --git a/design/memory.md b/design/memory.md
index 3c85fd9b..871fe0c8 100644
--- a/design/memory.md
+++ b/design/memory.md
@@ -171,7 +171,7 @@ any pages after the region end should be 0).
 
 ## Paging Allocator (`memory.h`)
 
-Paging allocator (aka `kmalloc` and `kfree`) is responsible for connecting the
+Paging allocator (aka `pmalloc` and `pfree`) is responsible for connecting the
 physical memory allocator (ram) and page tables (mmu). This allocator keeps a
 linked list of tables, 1022 entries each.
 
diff --git a/src/apps/demo/src/demo.c b/src/apps/demo/src/demo.c
index 3a2d92e4..31803f0e 100644
--- a/src/apps/demo/src/demo.c
+++ b/src/apps/demo/src/demo.c
@@ -11,7 +11,7 @@ int __start(size_t argc, char ** argv) {
     int store = 0;
     len += printf("The last part is pointers %8p\n", &store);
 
-    void * data = kmalloc(10);
+    void * data = pmalloc(10);
 
     printf("\nMalloc memory got pointer %p\n", data);
     printf("Float number %f or shorter %3f or digits %.4f or lead %.04f\n", 3.14, 31.45, 3.14, 3.14);
diff --git a/src/drivers/src/ata.c b/src/drivers/src/ata.c
index 619a96b7..05234c6b 100644
--- a/src/drivers/src/ata.c
+++ b/src/drivers/src/ata.c
@@ -4,6 +4,7 @@
 #include "cpu/ports.h"
 #include "debug.h"
 #include "drivers/rtc.h"
+#include "kernel.h"
 #include "libc/memory.h"
 #include "libc/proc.h"
 #include "libc/stdio.h"
diff --git a/src/drivers/src/disk.c b/src/drivers/src/disk.c
index f2bcd503..51c30f5c 100644
--- a/src/drivers/src/disk.c
+++ b/src/drivers/src/disk.c
@@ -2,6 +2,7 @@
 
 #include "drivers/ata.h"
 #include "drivers/ramdisk.h"
+#include "kernel.h"
 #include "libc/memory.h"
 #include "libc/string.h"
 
diff --git a/src/drivers/src/ramdisk.c b/src/drivers/src/ramdisk.c
index 1872e026..aa95d7ea 100644
--- a/src/drivers/src/ramdisk.c
+++ b/src/drivers/src/ramdisk.c
@@ -1,5 +1,6 @@
 #include "drivers/ramdisk.h"
 
+#include "kernel.h"
 #include "libc/memory.h"
 #include "libc/proc.h"
 #include "libc/string.h"
diff --git a/src/drivers/src/tar.c b/src/drivers/src/tar.c
index cfa6d99b..44209661 100644
--- a/src/drivers/src/tar.c
+++ b/src/drivers/src/tar.c
@@ -2,6 +2,7 @@
 
 #include <stdint.h>
 
+#include "kernel.h"
 #include "libc/memory.h"
 #include "libc/proc.h"
 #include "libc/stdio.h"
diff --git a/src/io/src/file.c b/src/io/src/file.c
index 006e9200..371cf5fe 100644
--- a/src/io/src/file.c
+++ b/src/io/src/file.c
@@ -1,5 +1,6 @@
 #include "io/file.h"
 
+#include "kernel.h"
 #include "libc/memory.h"
 #include "libk/sys_call.h"
 
diff --git a/src/kernel/include/kernel.h b/src/kernel/include/kernel.h
index 72610cd2..7ed55821 100644
--- a/src/kernel/include/kernel.h
+++ b/src/kernel/include/kernel.h
@@ -66,6 +66,10 @@ int kernel_call_as_proc(int pid, _proc_call_t fn, void * data);
 
 int kernel_switch_task(int next_pid);
 
+void * kmalloc(size_t size);
+void * krealloc(void * ptr, size_t size);
+void   kfree(void * ptr);
+
 #ifdef TESTING
 #define NO_RETURN
 #else
diff --git a/src/kernel/src/kernel.c b/src/kernel/src/kernel.c
index e59ac537..f539b616 100644
--- a/src/kernel/src/kernel.c
+++ b/src/kernel/src/kernel.c
@@ -284,6 +284,18 @@ process_t * kernel_find_pid(int pid) {
     return pm_find_pid(&__kernel.pm, pid);
 }
 
+void * kmalloc(size_t size) {
+    return memory_alloc(&__kernel.kernel_memory, size);
+}
+
+void * krealloc(void * ptr, size_t size) {
+    return memory_realloc(&__kernel.kernel_memory, ptr, size);
+}
+
+void kfree(void * ptr) {
+    memory_free(&__kernel.kernel_memory, ptr);
+}
+
 static void cursor() {
     vga_cursor(3, 3);
 
diff --git a/src/kernel/src/term.c b/src/kernel/src/term.c
index 6bba009f..746a2246 100644
--- a/src/kernel/src/term.c
+++ b/src/kernel/src/term.c
@@ -340,9 +340,9 @@ static void exec_buff() {
 
     // Free parsed args
     for (size_t i = 0; i < argc; i++) {
-        kfree(argv[i]);
+        pfree(argv[i]);
     }
-    kfree(argv);
+    pfree(argv);
 }
 
 static bool is_ws(char c) {
@@ -412,7 +412,7 @@ static char ** parse_args(const char * line, size_t * out_len) {
     }
 
     *out_len      = len;
-    char ** args  = kmalloc(sizeof(char *) * len);
+    char ** args  = pmalloc(sizeof(char *) * len);
     size_t  arg_i = 0;
 
     while (*line) {
@@ -443,7 +443,7 @@ static char ** parse_args(const char * line, size_t * out_len) {
 
             line++;
 
-            args[arg_i] = kmalloc(sizeof(char) * next);
+            args[arg_i] = pmalloc(sizeof(char) * next);
             kmemcpy(args[arg_i], line, next - 1);
             args[arg_i][next - 1] = 0;
             arg_i++;
@@ -459,7 +459,7 @@ static char ** parse_args(const char * line, size_t * out_len) {
         }
 
         size_t word_len = line - start;
-        args[arg_i]     = kmalloc(sizeof(char) * word_len + 1);
+        args[arg_i]     = pmalloc(sizeof(char) * word_len + 1);
         kmemcpy(args[arg_i], start, word_len);
         args[arg_i][word_len] = 0;
         arg_i++;
diff --git a/src/libc/include/libc/memory.h b/src/libc/include/libc/memory.h
index 0f17c41c..fcdb8307 100644
--- a/src/libc/include/libc/memory.h
+++ b/src/libc/include/libc/memory.h
@@ -7,8 +7,8 @@
 #include "memory_alloc.h"
 
 void   init_malloc(memory_t * memory);
-void * kmalloc(size_t size);
-void * krealloc(void * ptr, size_t size);
-void   kfree(void * ptr);
+void * pmalloc(size_t size);
+void * prealloc(void * ptr, size_t size);
+void   pfree(void * ptr);
 
 #endif // LIBC_MEMORY_H
diff --git a/src/libc/src/array.c b/src/libc/src/array.c
index 46e1fdb5..3f33a303 100644
--- a/src/libc/src/array.c
+++ b/src/libc/src/array.c
@@ -11,7 +11,7 @@ int arr_create(arr_t * arr, size_t size, size_t elem_size) {
         return -1;
     }
 
-    arr->data = kmalloc(size * elem_size);
+    arr->data = pmalloc(size * elem_size);
     if (!arr->data) {
         return -1;
     }
@@ -25,7 +25,7 @@ int arr_create(arr_t * arr, size_t size, size_t elem_size) {
 
 void arr_free(arr_t * arr) {
     if (arr && arr->data) {
-        kfree(arr->data);
+        pfree(arr->data);
         arr->data = 0;
     }
 }
@@ -119,7 +119,7 @@ static void * arr_at_no_limit(const arr_t * arr, size_t i) {
 
 static int grow_array(arr_t * arr) {
     size_t new_size = arr->size + (arr->size / 2);
-    void * new_data = krealloc(arr->data, new_size);
+    void * new_data = prealloc(arr->data, new_size);
     if (!new_data) {
         return -1;
     }
diff --git a/src/libc/src/circular_buffer.c b/src/libc/src/circular_buffer.c
index 585c2c68..6c9a0d32 100644
--- a/src/libc/src/circular_buffer.c
+++ b/src/libc/src/circular_buffer.c
@@ -11,7 +11,7 @@ int cb_create(cb_t * cb, size_t size, size_t elem_size) {
         return -1;
     }
 
-    cb->buff = kmalloc(size * elem_size);
+    cb->buff = pmalloc(size * elem_size);
     if (!cb->buff) {
         return -1;
     }
@@ -26,7 +26,7 @@ int cb_create(cb_t * cb, size_t size, size_t elem_size) {
 
 void cb_free(cb_t * cb) {
     if (cb && cb->buff) {
-        kfree(cb->buff);
+        pfree(cb->buff);
         cb->buff = 0;
     }
 }
diff --git a/src/libc/src/memory.c b/src/libc/src/memory.c
index 66165848..1c1fe2c3 100644
--- a/src/libc/src/memory.c
+++ b/src/libc/src/memory.c
@@ -9,14 +9,14 @@ void init_malloc(memory_t * memory) {
     __memory = memory;
 }
 
-void * kmalloc(size_t size) {
+void * pmalloc(size_t size) {
     return memory_alloc(__memory, size);
 }
 
-void * krealloc(void * ptr, size_t size) {
+void * prealloc(void * ptr, size_t size) {
     return memory_realloc(__memory, ptr, size);
 }
 
-void kfree(void * ptr) {
+void pfree(void * ptr) {
     memory_free(__memory, ptr);
 }
diff --git a/src/libc/src/signal.c b/src/libc/src/signal.c
index 641e8606..7a08a566 100644
--- a/src/libc/src/signal.c
+++ b/src/libc/src/signal.c
@@ -36,7 +36,7 @@ int register_signal(int sig_no, signal_handler callback) {
         sig = sig->next;
     }
 
-    sig = kmalloc(sizeof(signal_t));
+    sig = pmalloc(sizeof(signal_t));
     if (!sig) {
         return -1;
     }
diff --git a/tests/src/libc/test_array.cpp b/tests/src/libc/test_array.cpp
index ca65e8ff..c29170c2 100644
--- a/tests/src/libc/test_array.cpp
+++ b/tests/src/libc/test_array.cpp
@@ -19,8 +19,8 @@ class Array : public testing::Test {
         arr_create(&arr, 3, 1);
         arr_size(&arr);
 
-        RESET_FAKE(kmalloc);
-        kmalloc_fake.custom_fake = malloc;
+        RESET_FAKE(pmalloc);
+        pmalloc_fake.custom_fake = malloc;
     }
 
     void TearDown() override {
@@ -42,15 +42,15 @@ TEST_F(Array, arr_create) {
     EXPECT_NE(0, arr_create(0, 0, 1));
     EXPECT_NE(0, arr_create(&arr, 1, 0));
     EXPECT_NE(0, arr_create(&arr, 0, 1));
-    EXPECT_EQ(0, kmalloc_fake.call_count);
-    EXPECT_EQ(0, kfree_fake.call_count);
+    EXPECT_EQ(0, pmalloc_fake.call_count);
+    EXPECT_EQ(0, pfree_fake.call_count);
 
     // Good args
     EXPECT_EQ(0, arr_create(&arr, 4, 1));
     EXPECT_EQ(0, arr_size(&arr));
 
-    ASSERT_EQ(1, kmalloc_fake.call_count);
-    EXPECT_EQ(4, kmalloc_fake.arg0_val);
+    ASSERT_EQ(1, pmalloc_fake.call_count);
+    EXPECT_EQ(4, pmalloc_fake.arg0_val);
 
     arr_free(&arr);
 
@@ -60,31 +60,31 @@ TEST_F(Array, arr_create) {
     EXPECT_EQ(0, arr_create(&arr, 4, 2));
     EXPECT_EQ(0, arr_size(&arr));
 
-    ASSERT_EQ(1, kmalloc_fake.call_count);
-    EXPECT_EQ(8, kmalloc_fake.arg0_val);
+    ASSERT_EQ(1, pmalloc_fake.call_count);
+    EXPECT_EQ(8, pmalloc_fake.arg0_val);
 
     arr_free(&arr);
 
     SetUp();
 
-    kmalloc_fake.custom_fake = 0;
-    kmalloc_fake.return_val  = 0;
+    pmalloc_fake.custom_fake = 0;
+    pmalloc_fake.return_val  = 0;
 
     // First malloc fails
     EXPECT_NE(0, arr_create(&arr, 4, 1));
-    EXPECT_EQ(1, kmalloc_fake.call_count);
-    EXPECT_EQ(4, kmalloc_fake.arg0_val);
+    EXPECT_EQ(1, pmalloc_fake.call_count);
+    EXPECT_EQ(4, pmalloc_fake.arg0_val);
 }
 
 TEST_F(Array, arr_free) {
     // Invalid parameters
     arr_free(0);
-    EXPECT_EQ(0, kfree_fake.call_count);
+    EXPECT_EQ(0, pfree_fake.call_count);
 
     void * data = arr.data;
     arr_free(&arr);
-    EXPECT_EQ(1, kfree_fake.call_count);
-    EXPECT_EQ(data, kfree_fake.arg0_val);
+    EXPECT_EQ(1, pfree_fake.call_count);
+    EXPECT_EQ(data, pfree_fake.arg0_val);
     EXPECT_EQ(0, arr.data);
 }
 
@@ -114,9 +114,9 @@ TEST_F(Array, arr_size) {
     EXPECT_EQ(0, arr_insert(&arr, 3, &c));
     EXPECT_EQ(4, arr_size(&arr));
 
-    ASSERT_EQ(1, krealloc_fake.call_count);
-    EXPECT_EQ(old_data, krealloc_fake.arg0_val);
-    EXPECT_EQ(4, krealloc_fake.arg1_val);
+    ASSERT_EQ(1, prealloc_fake.call_count);
+    EXPECT_EQ(old_data, prealloc_fake.arg0_val);
+    EXPECT_EQ(4, prealloc_fake.arg1_val);
 }
 
 TEST_F(Array, arr_data) {
@@ -263,8 +263,8 @@ TEST_F(Array, arr_insert) {
 TEST_F(Array, array_insert_grow_fails) {
     fill_array();
 
-    krealloc_fake.custom_fake = 0;
-    krealloc_fake.return_val  = 0;
+    prealloc_fake.custom_fake = 0;
+    prealloc_fake.return_val  = 0;
 
     char c = '1';
     EXPECT_NE(0, arr_insert(&arr, 0, &c));
diff --git a/tests/src/libc/test_circular_buffer.cpp b/tests/src/libc/test_circular_buffer.cpp
index cf10d65b..63a74e73 100644
--- a/tests/src/libc/test_circular_buffer.cpp
+++ b/tests/src/libc/test_circular_buffer.cpp
@@ -18,8 +18,8 @@ class CircularBuffer : public testing::Test {
 
         cb_create(&cbuff, 3, 1);
 
-        RESET_FAKE(kmalloc);
-        kmalloc_fake.custom_fake = malloc;
+        RESET_FAKE(pmalloc);
+        pmalloc_fake.custom_fake = malloc;
     }
 
     void TearDown() override {
@@ -34,16 +34,16 @@ TEST_F(CircularBuffer, cb_create) {
     EXPECT_NE(0, cb_create(0, 0, 1));
     EXPECT_NE(0, cb_create(&cbuff, 1, 0));
     EXPECT_NE(0, cb_create(&cbuff, 0, 1));
-    EXPECT_EQ(0, kmalloc_fake.call_count);
-    EXPECT_EQ(0, kfree_fake.call_count);
+    EXPECT_EQ(0, pmalloc_fake.call_count);
+    EXPECT_EQ(0, pfree_fake.call_count);
 
     // Good args
     EXPECT_EQ(0, cb_create(&cbuff, 4, 1));
     EXPECT_EQ(0, cb_len(&cbuff));
     EXPECT_EQ(4, cb_buff_size(&cbuff));
 
-    ASSERT_EQ(1, kmalloc_fake.call_count);
-    EXPECT_EQ(4, kmalloc_fake.arg0_val);
+    ASSERT_EQ(1, pmalloc_fake.call_count);
+    EXPECT_EQ(4, pmalloc_fake.arg0_val);
 
     cb_free(&cbuff);
 
@@ -54,30 +54,30 @@ TEST_F(CircularBuffer, cb_create) {
     EXPECT_EQ(0, cb_len(&cbuff));
     EXPECT_EQ(4, cb_buff_size(&cbuff));
 
-    ASSERT_EQ(1, kmalloc_fake.call_count);
-    EXPECT_EQ(8, kmalloc_fake.arg0_val);
+    ASSERT_EQ(1, pmalloc_fake.call_count);
+    EXPECT_EQ(8, pmalloc_fake.arg0_val);
 
     cb_free(&cbuff);
 
     SetUp();
 
-    kmalloc_fake.custom_fake = 0;
-    kmalloc_fake.return_val  = 0;
+    pmalloc_fake.custom_fake = 0;
+    pmalloc_fake.return_val  = 0;
 
     // First malloc fails
     EXPECT_NE(0, cb_create(&cbuff, 4, 1));
-    EXPECT_EQ(1, kmalloc_fake.call_count);
-    EXPECT_EQ(4, kmalloc_fake.arg0_val);
+    EXPECT_EQ(1, pmalloc_fake.call_count);
+    EXPECT_EQ(4, pmalloc_fake.arg0_val);
 }
 
 TEST_F(CircularBuffer, cb_free) {
     cb_free(0);
-    EXPECT_EQ(0, kfree_fake.call_count);
+    EXPECT_EQ(0, pfree_fake.call_count);
 
     void * data = cbuff.buff;
     cb_free(&cbuff);
-    EXPECT_EQ(1, kfree_fake.call_count);
-    EXPECT_EQ(data, kfree_fake.arg0_val);
+    EXPECT_EQ(1, pfree_fake.call_count);
+    EXPECT_EQ(data, pfree_fake.arg0_val);
     EXPECT_EQ(0, cbuff.buff);
 }
 
diff --git a/tests/src/libc/test_memory.cpp b/tests/src/libc/test_memory.cpp
index 7d81d098..c4924a27 100644
--- a/tests/src/libc/test_memory.cpp
+++ b/tests/src/libc/test_memory.cpp
@@ -22,26 +22,26 @@ class LibC : public ::testing::Test {
     }
 };
 
-TEST_F(LibC, kmalloc) {
-    void * ptr = kmalloc(12);
+TEST_F(LibC, pmalloc) {
+    void * ptr = pmalloc(12);
     EXPECT_EQ(1, memory_alloc_fake.call_count);
     EXPECT_EQ(&memory, memory_alloc_fake.arg0_val);
     EXPECT_EQ(12, memory_alloc_fake.arg1_val);
 }
 
-TEST_F(LibC, krealloc) {
+TEST_F(LibC, prealloc) {
     char buff[12];
 
-    void * ptr = krealloc(buff, 12);
+    void * ptr = prealloc(buff, 12);
     EXPECT_EQ(1, memory_realloc_fake.call_count);
     EXPECT_EQ(&memory, memory_realloc_fake.arg0_val);
     EXPECT_EQ(buff, memory_realloc_fake.arg1_val);
     EXPECT_EQ(12, memory_realloc_fake.arg2_val);
 }
 
-TEST_F(LibC, kfree) {
+TEST_F(LibC, pfree) {
     char buff[12];
-    kfree(buff);
+    pfree(buff);
 
     EXPECT_EQ(1, memory_free_fake.call_count);
     EXPECT_EQ(&memory, memory_free_fake.arg0_val);
diff --git a/tests/src/libc/test_signal.cpp b/tests/src/libc/test_signal.cpp
index d5ea6e1f..1d3e472d 100644
--- a/tests/src/libc/test_signal.cpp
+++ b/tests/src/libc/test_signal.cpp
@@ -23,13 +23,13 @@ class Signal : public testing::Test {
 TEST_F(Signal, register_signal) {
     // Invalid parameters
     EXPECT_NE(0, register_signal(0, 0));
-    EXPECT_EQ(0, kmalloc_fake.call_count);
+    EXPECT_EQ(0, pmalloc_fake.call_count);
     EXPECT_EQ(0, _sys_register_signals_fake.call_count);
 
     // Success
     EXPECT_EQ(0, register_signal(0, callback));
-    EXPECT_EQ(1, kmalloc_fake.call_count);
-    EXPECT_EQ(12, kmalloc_fake.arg0_val);
+    EXPECT_EQ(1, pmalloc_fake.call_count);
+    EXPECT_EQ(12, pmalloc_fake.arg0_val);
 
     signal_callback_t signal_callback = (signal_callback_t)_sys_register_signals_fake.arg0_val;
 
@@ -39,15 +39,15 @@ TEST_F(Signal, register_signal) {
     signal_callback(1);
     EXPECT_EQ(1, callback_fake.call_count);
 
-    RESET_FAKE(kmalloc);
-    kmalloc_fake.custom_fake = malloc;
+    RESET_FAKE(pmalloc);
+    pmalloc_fake.custom_fake = malloc;
 
     // Duplicate registered
     EXPECT_NE(0, register_signal(0, callback));
-    EXPECT_EQ(0, kmalloc_fake.call_count);
+    EXPECT_EQ(0, pmalloc_fake.call_count);
 
-    kmalloc_fake.custom_fake = 0;
-    kmalloc_fake.return_val  = 0;
+    pmalloc_fake.custom_fake = 0;
+    pmalloc_fake.return_val  = 0;
 
     // malloc fails
     EXPECT_NE(0, register_signal(1, callback));
diff --git a/tests/src/mocks/include/libc/memory.mock.h b/tests/src/mocks/include/libc/memory.mock.h
index 10025763..0e0143d1 100644
--- a/tests/src/mocks/include/libc/memory.mock.h
+++ b/tests/src/mocks/include/libc/memory.mock.h
@@ -7,9 +7,9 @@ extern "C" {
 #include "fff.h"
 #include "libc/memory.h"
 
-DECLARE_FAKE_VALUE_FUNC(void *, kmalloc, size_t);
-DECLARE_FAKE_VALUE_FUNC(void *, krealloc, void *, size_t);
-DECLARE_FAKE_VOID_FUNC(kfree, void *);
+DECLARE_FAKE_VALUE_FUNC(void *, pmalloc, size_t);
+DECLARE_FAKE_VALUE_FUNC(void *, prealloc, void *, size_t);
+DECLARE_FAKE_VOID_FUNC(pfree, void *);
 
 void reset_libc_memory_mock(void);
 
diff --git a/tests/src/mocks/src/libc.mock.c b/tests/src/mocks/src/libc.mock.c
index 1601e744..1374fed6 100644
--- a/tests/src/mocks/src/libc.mock.c
+++ b/tests/src/mocks/src/libc.mock.c
@@ -8,18 +8,18 @@
 
 // libc/memory.h
 
-DEFINE_FAKE_VALUE_FUNC(void *, kmalloc, size_t);
-DEFINE_FAKE_VALUE_FUNC(void *, krealloc, void *, size_t);
-DEFINE_FAKE_VOID_FUNC(kfree, void *);
+DEFINE_FAKE_VALUE_FUNC(void *, pmalloc, size_t);
+DEFINE_FAKE_VALUE_FUNC(void *, prealloc, void *, size_t);
+DEFINE_FAKE_VOID_FUNC(pfree, void *);
 
 void reset_libc_memory_mock(void) {
-    RESET_FAKE(kmalloc);
-    RESET_FAKE(krealloc);
-    RESET_FAKE(kfree);
+    RESET_FAKE(pmalloc);
+    RESET_FAKE(prealloc);
+    RESET_FAKE(pfree);
 
-    kmalloc_fake.custom_fake  = malloc;
-    krealloc_fake.custom_fake = realloc;
-    kfree_fake.custom_fake    = free;
+    pmalloc_fake.custom_fake  = malloc;
+    prealloc_fake.custom_fake = realloc;
+    pfree_fake.custom_fake    = free;
 }
 
 // libc/proc.h