diff --git a/Apps/Gargantua/main.vp b/Apps/Gargantua/main.vp
index 70988ad..777a996 100644
--- a/Apps/Gargantua/main.vp
+++ b/Apps/Gargantua/main.vp
@@ -35,7 +35,7 @@ class V3:
     z: t.CFloat64T
 
     def __new__() -> 'V3' | t.CPtr:
-        return t.CVoid(uint64(_v3_pool.alloc(24)), t.CPtr)
+        return uint64(_v3_pool.alloc(24))
 
     def __init__(self, x: t.CFloat64T, y: t.CFloat64T, z: t.CFloat64T):
         self.x = x
@@ -94,25 +94,25 @@ def smoothstep(a: t.CFloat64T, b: t.CFloat64T, x: t.CFloat64T) -> t.CFloat64T:
 def setup_camera():
     global CAM, FWD, RIGHT, UP
     e: t.CFloat64T = CAM_ELEV * 3.14159265358979323846 / 180.0
-    CAM = t.CVoid(c.Addr(_g_cam), t.CPtr)
+    CAM = c.Addr(_g_cam)
     CAM.x = CAM_DIST * vm.cos(e)
     CAM.y = CAM_DIST * vm.sin(e)
     CAM.z = 0.0
     tmp0: V3 | t.CPtr = V3(0.0, 0.0, 0.0)
-    FWD = t.CVoid(c.Addr(_g_fwd), t.CPtr)
+    FWD = c.Addr(_g_fwd)
     tmp1: V3 | t.CPtr = tmp0 - CAM
     n1: V3 | t.CPtr = tmp1.nrm()
     FWD.x = n1.x
     FWD.y = n1.y
     FWD.z = n1.z
     tmp2: V3 | t.CPtr = V3(0.0, 1.0, 0.0)
-    RIGHT = t.CVoid(c.Addr(_g_right), t.CPtr)
+    RIGHT = c.Addr(_g_right)
     tmp3: V3 | t.CPtr = FWD.cross(tmp2)
     tmp4: V3 | t.CPtr = tmp3.nrm()
     RIGHT.x = tmp4.x
     RIGHT.y = tmp4.y
     RIGHT.z = tmp4.z
-    UP = t.CVoid(c.Addr(_g_up), t.CPtr)
+    UP = c.Addr(_g_up)
     tmp5: V3 | t.CPtr = RIGHT.cross(FWD)
     UP.x = tmp5.x
     UP.y = tmp5.y
diff --git a/Apps/Scene3D/main.vp b/Apps/Scene3D/main.vp
index 66c14cc..531a772 100644
--- a/Apps/Scene3D/main.vp
+++ b/Apps/Scene3D/main.vp
@@ -20,7 +20,7 @@ _canvas_ptr: vpui.FBCanvas | t.CPtr
 _s3d_ptr: gfx.Scene3D | t.CPtr
 _time_val: float = float(0.0)
 
-def _render_thread(arg: t.CPtr) -> t.CVoid:
+def _render_thread(arg: t.CPtr):
     root: vpui.Tk | t.CPtr = _root_ptr
     canvas: vpui.FBCanvas | t.CPtr = _canvas_ptr
     s3d: gfx.Scene3D | t.CPtr = _s3d_ptr
@@ -41,7 +41,7 @@ def _start() -> int | t.CExport:
     canvas: vpui.FBCanvas = vpui.FBCanvas(master, SCENE_W, SCENE_H)
     root.pack(0, vpui.PACK_TOP, vpui.FILL_BOTH, 1, 0, 0)
 
-    zbuf: float | t.CPtr = t.CVoid(c.Addr(_zbuf_mem), t.CPtr)
+    zbuf: float | t.CPtr = c.Addr(_zbuf_mem)
     string.memset(zbuf, 0, SCENE_W * SCENE_H * 8)
 
     fb: UINT32PTR = c.Addr(_fb_mem)
diff --git a/Libs/SerialLogger/serial_logger.vp b/Libs/SerialLogger/serial_logger.vp
index 98c796c..5416102 100644
--- a/Libs/SerialLogger/serial_logger.vp
+++ b/Libs/SerialLogger/serial_logger.vp
@@ -1,12 +1,12 @@
 import vpsdk.syscall as syscall
 import t, c
 
-def log_info(msg: t.CConst | t.CChar | t.CPtr) -> t.CVoid | t.CExport:
+export def log_info(msg: t.CConst | str):
     syscall._syscall1(uint64(syscall.SERIAL_PUTS), uint64("[SerialLogger] "))
     syscall._syscall1(uint64(syscall.SERIAL_PUTS), uint64(msg))
     syscall._syscall1(uint64(syscall.SERIAL_PUTS), uint64("\n"))
 
-def log_warn(msg: t.CConst | t.CChar | t.CPtr) -> t.CVoid | t.CExport:
+export def log_warn(msg: t.CConst | str):
     syscall._syscall1(uint64(syscall.SERIAL_PUTS), uint64("[SerialLogger:WARN] "))
     syscall._syscall1(uint64(syscall.SERIAL_PUTS), uint64(msg))
     syscall._syscall1(uint64(syscall.SERIAL_PUTS), uint64("\n"))
diff --git a/Libs/VPUI64/vpui64.vp b/Libs/VPUI64/vpui64.vp
index 955b9b9..f43e3fc 100644
--- a/Libs/VPUI64/vpui64.vp
+++ b/Libs/VPUI64/vpui64.vp
@@ -7,16 +7,16 @@ def color_rgb(r: uint8, g: uint8, b: uint8) -> uint32:
     return uint32(r) | (uint32(g) << 8) | (uint32(b) << 16)
 
 def get_winbuf(win_id: int) -> UINT32PTR:
-    return t.CVoid(syscall._syscall2(uint64(syscall.GET_WINBUF), uint64(win_id), 0), t.CPtr)
+    return syscall._syscall2(uint64(syscall.GET_WINBUF), uint64(win_id), 0)
 
-def win_flush(win_id: int) -> t.CVoid:
+def win_flush(win_id: int):
     syscall._syscall2(uint64(syscall.WIN_FLUSH), uint64(win_id), 0)
 
-def draw_pixel(buf: UINT32PTR, bw: int, x: int, y: int, color: uint32) -> t.CVoid | t.CExport:
+export def draw_pixel(buf: UINT32PTR, bw: int, x: int, y: int, color: uint32):
     if x < 0 or y < 0: return
     buf[y * bw + x] = color
 
-def draw_line(buf: UINT32PTR, bw: int, x0: int, y0: int, x1: int, y1: int, color: uint32) -> t.CVoid | t.CExport:
+export def draw_line(buf: UINT32PTR, bw: int, x0: int, y0: int, x1: int, y1: int, color: uint32):
     dx: int = x1 - x0
     dy: int = y1 - y0
     sx: int = 1
@@ -41,13 +41,13 @@ def draw_line(buf: UINT32PTR, bw: int, x0: int, y0: int, x1: int, y1: int, color
             err += dx
             y0 += sy
 
-def draw_rect(buf: UINT32PTR, bw: int, rx: int, ry: int, rw: int, rh: int, color: uint32) -> t.CVoid | t.CExport:
+export def draw_rect(buf: UINT32PTR, bw: int, rx: int, ry: int, rw: int, rh: int, color: uint32):
     draw_line(buf, bw, rx, ry, rx + rw - 1, ry, color)
     draw_line(buf, bw, rx + rw - 1, ry, rx + rw - 1, ry + rh - 1, color)
     draw_line(buf, bw, rx + rw - 1, ry + rh - 1, rx, ry + rh - 1, color)
     draw_line(buf, bw, rx, ry + rh - 1, rx, ry, color)
 
-def fill_rect(buf: UINT32PTR, bw: int, rx: int, ry: int, rw: int, rh: int, color: uint32) -> t.CVoid | t.CExport:
+export def fill_rect(buf: UINT32PTR, bw: int, rx: int, ry: int, rw: int, rh: int, color: uint32):
     if rx < 0: rw += rx; rx = 0
     if ry < 0: rh += ry; ry = 0
     if rw <= 0 or rh <= 0: return
@@ -59,7 +59,7 @@ def fill_rect(buf: UINT32PTR, bw: int, rx: int, ry: int, rw: int, rh: int, color
             px += 1
         py += 1
 
-def draw_circle(buf: UINT32PTR, bw: int, cx: int, cy: int, r: int, color: uint32) -> t.CVoid | t.CExport:
+export def draw_circle(buf: UINT32PTR, bw: int, cx: int, cy: int, r: int, color: uint32):
     x: int = r
     y: int = 0
     d: int = 1 - r
diff --git a/VKernel/Kernel/drivers/devfs/devfs.vp b/VKernel/Kernel/drivers/devfs/devfs.vp
index 066ba57..688b7a5 100644
--- a/VKernel/Kernel/drivers/devfs/devfs.vp
+++ b/VKernel/Kernel/drivers/devfs/devfs.vp
@@ -487,7 +487,7 @@ class mouse_device(devfs_file):
             uint8(buffer, t.CPtr)[0] = pkt.buttons
         # 完整包需要 1(buttons) + 4(x) + 4(y) = 9 字节，否则越界写
         if size >= 9:
-            buf: uint32 | t.CPtr = t.CVoid(uint64(buffer) + 1, t.CPtr)
+            buf: uint32 | t.CPtr = t.CPtr(uint64(buffer) + 1)
             int32(buf, t.CPtr)[0] = mouse.get_x()
             int32(buf, t.CPtr)[1] = mouse.get_y()
             return 9
diff --git a/VKernel/Kernel/drivers/fs/fat32/example_fs.vp b/VKernel/Kernel/drivers/fs/fat32/example_fs.vp
index fbeb1d5..1e4599e 100644
--- a/VKernel/Kernel/drivers/fs/fat32/example_fs.vp
+++ b/VKernel/Kernel/drivers/fs/fat32/example_fs.vp
@@ -116,7 +116,7 @@ def example_main() -> int:
         fp3: types.fileobj | t.CPtr = fs.open("/test_dir_1/file1.txt", types.FA_OPEN_EXISTING | types.FA_READ)
         if fp3 is not None:
             buf: t.CArray[uint8, 256]
-            read_bytes: uint32 = fs.read(fp3, t.CVoid(c.Addr(buf[0]), t.CPtr), 256)
+            read_bytes: uint32 = fs.read(fp3, c.Addr(buf[0]), 256)
             print(f"读取字节数: {read_bytes}")
             print(f"文件内容: {t.CChar(c.Addr(buf[0]), t.CPtr)}")
             
@@ -125,7 +125,7 @@ def example_main() -> int:
             pos: uint32 = fs.tell(fp3)
             print(f"seek 到位置 5, 当前位置: {pos}")
             
-            read_bytes2: uint32 = fs.read(fp3, t.CVoid(c.Addr(buf[0]), t.CPtr), 256)
+            read_bytes2: uint32 = fs.read(fp3, c.Addr(buf[0]), 256)
             print(f"从位置 5 读取: {t.CChar(c.Addr(buf[0]), t.CPtr)}")
             
             # 获取文件大小
@@ -141,7 +141,7 @@ def example_main() -> int:
             k: int
             for k in range(1024):
                 large_data[k] = uint8(ord('A') + (k % 26))
-            written3: uint32 = fs.write(fp4, t.CVoid(c.Addr(large_data[0]), t.CPtr), 1024)
+            written3: uint32 = fs.write(fp4, c.Addr(large_data[0]), 1024)
             print(f"创建大文件, 写入: {written3} 字节")
             fs.close(fp4)
         print()
diff --git a/VKernel/Kernel/drivers/video/vesafb/vga.vp b/VKernel/Kernel/drivers/video/vesafb/vga.vp
index 074009c..1072c19 100644
--- a/VKernel/Kernel/drivers/video/vesafb/vga.vp
+++ b/VKernel/Kernel/drivers/video/vesafb/vga.vp
@@ -343,7 +343,7 @@ class _VGAScreenDriver:
         self.ClearScreen(self.BgColor)
 
     # 检测硬件颜色格式 - 优化测试逻辑，避免误判
-    def DetectColorFormat(self) -> t.CStatic | t.CVoid:
+    def DetectColorFormat(self):
         if self.fb is None: return
         fb: t.CUnsignedChar | t.CPtr = t.CUnsignedChar(self.fb, t.CPtr)
         testX: int = 0
@@ -360,7 +360,7 @@ class _VGAScreenDriver:
         b: t.CUnsignedChar = fb[offset + 0]
         g: t.CUnsignedChar = fb[offset + 1]
         r: t.CUnsignedChar = fb[offset + 2]
-        # t.CVoid(fb[offset + 3]) # 忽略Alpha
+        # t\.CVoid(fb[offset + 3]) # 忽略Alpha
         # 恢复原始像素
         c.Set(c.Deref(uint32(fb + offset, t.CPtr)), OriginalPixel)
         # 判定颜色格式
diff --git a/VKernel/Kernel/execrunner/elf.vp b/VKernel/Kernel/execrunner/elf.vp
index 583c546..8b4f243 100644
--- a/VKernel/Kernel/execrunner/elf.vp
+++ b/VKernel/Kernel/execrunner/elf.vp
@@ -133,10 +133,10 @@ def load_elf(path: t.CConst | str, do_map: int = 1) -> t.CPtr:
     # [DIAG] read_len 实际值 + call 后 RAX 快照：区分"call 返回错"（rl=0 rax=0）
     # vs "store 后 RAX 被覆盖"（rl=0 rax=64）
     _rax_v2: uint64 = 0
-    # 读 RAX 未声明输入：至少须声明 CLOBBER_RAX，让编译器知道本块不保留
-    # RAX（此前只声明 ~{memory}，编译器可假设 RAX 存活 → 读到的值不保证是
-    # 紧邻 call 的返回值）。N16。（本块为 [DIAG] 探针，问题定位后建议删除。）
-    c.Asm(f"""mov {c.AsmOut(_rax_v2, t.ASM_DESCR.OUTPUT_REG)}, rax""",
+    # 读 RAX 未声明输入：至少须声明 CLOBBER_RAX，让编译器知道本块不保留
+    # RAX（此前只声明 ~{memory}，编译器可假设 RAX 存活 → 读到的值不保证是
+    # 紧邻 call 的返回值）。N16。（本块为 [DIAG] 探针，问题定位后建议删除。）
+    c.Asm(f"""mov {c.AsmOut(_rax_v2, t.ASM_DESCR.OUTPUT_REG)}, rax""",
           op=[t.ASM_DESCR.CLOBBER_MEMORY, t.ASM_DESCR.CLOBBER_RAX])
     _dbrl: t.CArray[t.CChar, 96]
     viperlib.snprintf(c.Addr(_dbrl), 96, "[elf] rl=%lu rax=0x%lx\n", read_len, _rax_v2)
@@ -254,7 +254,7 @@ def load_elf(path: t.CConst | str, do_map: int = 1) -> t.CPtr:
         return None
 
     phys_base_aligned: uint64 = (uint64(raw_alloc) + uint64(0xFFF)) & ~uint64(0xFFF)
-    phys_base: t.CPtr = t.CVoid(phys_base_aligned, t.CPtr)
+    phys_base: t.CPtr = t.CPtr(phys_base_aligned)
 
     string.memset(phys_base, 0, total_pages * 0x1000)
 
@@ -265,14 +265,14 @@ def load_elf(path: t.CConst | str, do_map: int = 1) -> t.CPtr:
             filesz: uint64 = phdr_bufs[pi].p_filesz
             memsz: uint64 = phdr_bufs[pi].p_memsz
             dest_off: uint64 = vaddr - lowest_vaddr
-            dest: t.CPtr = t.CVoid(uint64(phys_base) + dest_off, t.CPtr)
+            dest: t.CPtr = t.CPtr(uint64(phys_base) + dest_off)
 
             if filesz > 0:
                 fat32.seek(fp, uint32(file_off))
                 fat32.read(fp, dest, uint32(filesz))
 
             if memsz > filesz:
-                bss_start: t.CPtr = t.CVoid(uint64(dest) + filesz, t.CPtr)
+                bss_start: t.CPtr = t.CPtr(uint64(dest) + filesz)
                 bss_len: uint64 = memsz - filesz
                 string.memset(bss_start, 0, bss_len)
 
@@ -296,7 +296,7 @@ def load_elf(path: t.CConst | str, do_map: int = 1) -> t.CPtr:
             page_flags: uint64 = paging.PTE_PRESENT | paging.PTE_WRITABLE | paging.PTE_USER
             paging.MapPage(virt_addr, phys_addr, page_flags)
 
-    entry_addr: t.CPtr = t.CVoid(entry_point, t.CPtr)
+    entry_addr: t.CPtr = t.CPtr(entry_point)
 
     return entry_addr
 
@@ -530,7 +530,7 @@ def _resolve_symbol(name: t.CConst | t.CChar | t.CPtr) -> t.CPtr:
             if c.Deref(cmp_name + i) != c.Deref("serial_puts" + i):
                 match = 0
         if match:
-            return t.CVoid(c.Addr(serial.puts), t.CPtr)
+            return c.Addr(serial.puts)
     return None
 
 _so_strtab: t.CPtr
@@ -629,7 +629,7 @@ def load_so(path: t.CConst | str) -> t.CPtr:
         return None
 
     phys_base_aligned: uint64 = (uint64(raw_alloc) + 0xFFF) & ~uint64(0xFFF)
-    phys_base: t.CPtr = t.CVoid(phys_base_aligned, t.CPtr)
+    phys_base: t.CPtr = t.CPtr(phys_base_aligned)
     string.memset(phys_base, 0, total_pages * 0x1000)
 
     for pi in range(phnum):
@@ -639,12 +639,12 @@ def load_so(path: t.CConst | str) -> t.CPtr:
             filesz: uint64 = phdr_bufs[pi].p_filesz
             memsz: uint64 = phdr_bufs[pi].p_memsz
             dest_off: uint64 = vaddr - lowest_vaddr
-            dest: t.CPtr = t.CVoid(uint64(phys_base) + dest_off, t.CPtr)
+            dest: t.CPtr = t.CPtr(uint64(phys_base) + dest_off)
             if filesz > 0:
                 fat32.seek(fp, uint32(file_off))
                 fat32.read(fp, dest, uint32(filesz))
             if memsz > filesz:
-                bss_start: t.CPtr = t.CVoid(uint64(dest) + filesz, t.CPtr)
+                bss_start: t.CPtr = t.CPtr(uint64(dest) + filesz)
                 bss_len: uint64 = memsz - filesz
                 string.memset(bss_start, 0, bss_len)
 
@@ -693,22 +693,22 @@ def load_so(path: t.CConst | str) -> t.CPtr:
         elif dyn_buf[di].d_tag == DT_JMPREL: jmprel_vaddr = dyn_buf[di].d_val
         elif dyn_buf[di].d_tag == DT_PLTRELSZ: pltrelsz = dyn_buf[di].d_val
 
-    strtab_ptr: t.CPtr = t.CVoid(strtab_vaddr + so_load_addr, t.CPtr)
-    symtab_ptr: t.CPtr = t.CVoid(symtab_vaddr + so_load_addr, t.CPtr)
+    strtab_ptr: t.CPtr = t.CPtr(strtab_vaddr + so_load_addr)
+    symtab_ptr: t.CPtr = t.CPtr(symtab_vaddr + so_load_addr)
 
     if rela_vaddr != 0 and relasz > 0:
         rela_count: uint64 = relasz // 24
         for ri in range(rela_count):
-            rela: Elf64_Rela | t.CPtr = t.CVoid(uint64(rela_vaddr) + so_load_addr + ri * 24, t.CPtr)
+            rela: Elf64_Rela | t.CPtr = t.CPtr(uint64(rela_vaddr) + so_load_addr + ri * 24)
             r_type: uint32 = uint32(rela.r_info & 0xFFFFFFFF)
             r_sym: uint32 = uint32(rela.r_info >> 32)
-            target_addr: t.CPtr = t.CVoid(rela.r_offset + so_load_addr, t.CPtr)
+            target_addr: t.CPtr = t.CPtr(rela.r_offset + so_load_addr)
             if r_type == R_X86_64_RELATIVE:
                 val: uint64 = uint64(rela.r_addend) + so_load_addr
                 string.memcpy(target_addr, c.Addr(val), 8)
             elif r_type == R_X86_64_64 or r_type == R_X86_64_GLOB_DAT or r_type == R_X86_64_JUMP_SLOT:
-                sym: Elf64_Sym | t.CPtr = t.CVoid(uint64(symtab_ptr) + uint64(r_sym) * syment, t.CPtr)
-                sym_name: t.CConst | t.CChar | t.CPtr = t.CConst(uint64(strtab_ptr) + sym.st_name, t.CPtr)
+                sym: Elf64_Sym | t.CPtr = t.CPtr(uint64(symtab_ptr) + uint64(r_sym) * syment)
+                sym_name: t.CConst | str = t.CPtr(uint64(strtab_ptr) + sym.st_name)
                 resolved: t.CPtr = _resolve_symbol(sym_name)
                 if resolved is not None:
                     val2: uint64 = uint64(resolved) + uint64(rela.r_addend)
@@ -720,13 +720,13 @@ def load_so(path: t.CConst | str) -> t.CPtr:
     if jmprel_vaddr != 0 and pltrelsz > 0:
         jmprel_count: uint64 = pltrelsz // 24
         for ji in range(jmprel_count):
-            rela2: Elf64_Rela | t.CPtr = t.CVoid(jmprel_vaddr + so_load_addr + ji * 24, t.CPtr)
+            rela2: Elf64_Rela | t.CPtr = t.CPtr(jmprel_vaddr + so_load_addr + ji * 24)
             r_type2: uint32 = uint32(rela2.r_info & 0xFFFFFFFF)
             r_sym2: uint32 = uint32(rela2.r_info >> 32)
-            target2: t.CPtr = t.CVoid(rela2.r_offset + so_load_addr, t.CPtr)
+            target2: t.CPtr = t.CPtr(rela2.r_offset + so_load_addr)
             if r_type2 == R_X86_64_JUMP_SLOT or r_type2 == R_X86_64_GLOB_DAT:
-                sym2: Elf64_Sym | t.CPtr = t.CVoid(uint64(symtab_ptr) + uint64(r_sym2) * syment, t.CPtr)
-                sym_name2: t.CConst | t.CChar | t.CPtr = t.CConst(uint64(strtab_ptr) + sym2.st_name, t.CPtr)
+                sym2: Elf64_Sym | t.CPtr = t.CPtr(uint64(symtab_ptr) + uint64(r_sym2) * syment)
+                sym_name2: t.CConst | str = t.CPtr(uint64(strtab_ptr) + sym2.st_name)
                 resolved2: t.CPtr = _resolve_symbol(sym_name2)
                 if resolved2 is not None:
                     val4: uint64 = uint64(resolved2) + uint64(rela2.r_addend)
@@ -748,8 +748,8 @@ def load_so(path: t.CConst | str) -> t.CPtr:
     _so_syment = syment
     _so_sym_count = 0
     if hash_vaddr != 0:
-        hash_ptr: t.CPtr = t.CVoid(hash_vaddr + so_load_addr, t.CPtr)
-        nchain: uint32 = c.Deref(t.CVoid(uint64(hash_ptr) + 4, t.CPtr))
+        hash_ptr: t.CPtr = t.CPtr(hash_vaddr + so_load_addr)
+        nchain: uint32 = c.Deref(t.CPtr(uint64(hash_ptr) + 4))
         _so_sym_count = int(nchain)
     elif syment > 0 and strtab_vaddr > symtab_vaddr and symtab_vaddr != 0:
         sym_tab_size: uint64 = strtab_vaddr - symtab_vaddr
@@ -760,22 +760,22 @@ def load_so(path: t.CConst | str) -> t.CPtr:
     serial.puts(cr)
 
     fat32.unlock()
-    return t.CVoid(base_vaddr, t.CPtr)
+    return t.CPtr(base_vaddr)
 
-def get_so_symbol(so_base: t.CPtr, name: t.CConst | t.CChar | t.CPtr, so_path: t.CConst | t.CChar | t.CPtr) -> t.CPtr:
+def get_so_symbol(so_base: t.CPtr, name: t.CConst | str, so_path: t.CConst | t.CChar | t.CPtr) -> t.CPtr:
     if _so_symtab is None or _so_strtab is None or _so_syment == 0:
         return None
     if name is None:
         return None
     for symi in range(_so_sym_count):
-        sb2: Elf64_Sym | t.CPtr = t.CVoid(uint64(_so_symtab) + uint64(symi) * _so_syment, t.CPtr)
+        sb2: Elf64_Sym | t.CPtr = t.CPtr(uint64(_so_symtab) + uint64(symi) * _so_syment)
         if sb2.st_value != 0 and sb2.st_shndx != 0:
             sym_name_off2: uint32 = sb2.st_name
             cmp_off2: uint32 = sym_name_off2
             match2: int = 0
             ni2: int = 0
             while True:
-                sc3: t.CChar = c.Deref(t.CVoid(uint64(_so_strtab) + cmp_off2 + ni2, t.CPtr))
+                sc3: t.CChar = c.Deref(t.CPtr(uint64(_so_strtab) + cmp_off2 + ni2))
                 nc3: t.CChar = c.Deref(name + ni2)
                 if sc3 != nc3:
                     break
@@ -788,7 +788,7 @@ def get_so_symbol(so_base: t.CPtr, name: t.CConst | t.CChar | t.CPtr, so_path: t
                 is_sha1_2: int = 0
                 sha1_len_2: uint32 = 0
                 while True:
-                    dc4: t.CChar = c.Deref(t.CVoid(uint64(_so_strtab) + dot_pos3, t.CPtr))
+                    dc4: t.CChar = c.Deref(t.CPtr(uint64(_so_strtab) + dot_pos3))
                     if dc4 == 46:
                         if sha1_len_2 >= 8:
                             is_sha1_2 = 1
@@ -805,7 +805,7 @@ def get_so_symbol(so_base: t.CPtr, name: t.CConst | t.CChar | t.CPtr, so_path: t
                     match2 = 1
                     ni2 = 0
                     while True:
-                        sc4: t.CChar = c.Deref(t.CVoid(uint64(_so_strtab) + cmp_off2 + ni2, t.CPtr))
+                        sc4: t.CChar = c.Deref(t.CPtr(uint64(_so_strtab) + cmp_off2 + ni2))
                         nc4: t.CChar = c.Deref(name + ni2)
                         if sc4 != nc4:
                             match2 = 0
@@ -816,8 +816,8 @@ def get_so_symbol(so_base: t.CPtr, name: t.CConst | t.CChar | t.CPtr, so_path: t
             if match2:
                 result_addr: uint64 = uint64(so_base) + sb2.st_value
                 dbg2: t.CArray[t.CChar, 80]
-                viperlib.snprintf(c.Addr(dbg2), 80, "[so] found '%s' at 0x%lx\n", t.CVoid(uint64(_so_strtab) + sym_name_off2, t.CPtr), result_addr)
+                viperlib.snprintf(c.Addr(dbg2), 80, "[so] found '%s' at 0x%lx\n", t.CPtr(uint64(_so_strtab) + sym_name_off2), result_addr)
                 serial.puts(dbg2)
-                return t.CVoid(result_addr, t.CPtr)
+                return t.CPtr(result_addr)
     serial.puts("[so] symbol not found\n")
     return None
diff --git a/VKernel/Kernel/intr/idt.vp b/VKernel/Kernel/intr/idt.vp
index 5d0aabb..bc9d262 100644
--- a/VKernel/Kernel/intr/idt.vp
+++ b/VKernel/Kernel/intr/idt.vp
@@ -283,43 +283,41 @@ def isrCommonhandler(interrupt: int):
         asm.sti()
         asm.hlt()
 
-def isr0_handler()  -> t.CExport | t.CVoid: isrCommonhandler(0)
-def isr1_handler()  -> t.CExport | t.CVoid: isrCommonhandler(1)
-def isr2_handler()  -> t.CExport | t.CVoid: isrCommonhandler(2)
-def isr3_handler()  -> t.CExport | t.CVoid: isrCommonhandler(3)
-def isr4_handler()  -> t.CExport | t.CVoid: isrCommonhandler(4)
-def isr5_handler()  -> t.CExport | t.CVoid: isrCommonhandler(5)
-def isr6_handler()  -> t.CExport | t.CVoid: isrCommonhandler(6)
-def isr7_handler()  -> t.CExport | t.CVoid: isrCommonhandler(7)
-def isr8_handler()  -> t.CExport | t.CVoid: isrCommonhandler(8)
-def isr9_handler()  -> t.CExport | t.CVoid: isrCommonhandler(9)
-def isr10_handler() -> t.CExport | t.CVoid: isrCommonhandler(10)
-def isr11_handler() -> t.CExport | t.CVoid: isrCommonhandler(11)
-def isr12_handler() -> t.CExport | t.CVoid: isrCommonhandler(12)
-def isr13_handler() -> t.CExport | t.CVoid:
-    isrCommonhandler(13)
-def isr14_handler() -> t.CExport | t.CVoid: isrCommonhandler(14)
-def isr15_handler() -> t.CExport | t.CVoid: isrCommonhandler(15)
-def isr16_handler() -> t.CExport | t.CVoid: isrCommonhandler(16)
-def isr17_handler() -> t.CExport | t.CVoid: isrCommonhandler(17)
-def isr18_handler() -> t.CExport | t.CVoid: isrCommonhandler(18)
-def isr19_handler() -> t.CExport | t.CVoid: isrCommonhandler(19)
-def isr20_handler() -> t.CExport | t.CVoid: isrCommonhandler(20)
-def isr21_handler() -> t.CExport | t.CVoid: isrCommonhandler(21)
-def isr22_handler() -> t.CExport | t.CVoid: isrCommonhandler(22)
-def isr23_handler() -> t.CExport | t.CVoid: isrCommonhandler(23)
-def isr24_handler() -> t.CExport | t.CVoid: isrCommonhandler(24)
-def isr25_handler() -> t.CExport | t.CVoid: isrCommonhandler(25)
-def isr26_handler() -> t.CExport | t.CVoid: isrCommonhandler(26)
-def isr27_handler() -> t.CExport | t.CVoid: isrCommonhandler(27)
-def isr28_handler() -> t.CExport | t.CVoid: isrCommonhandler(28)
-def isr29_handler() -> t.CExport | t.CVoid: isrCommonhandler(29)
-def isr30_handler() -> t.CExport | t.CVoid: isrCommonhandler(30)
-def isr31_handler() -> t.CExport | t.CVoid: isrCommonhandler(31)
-def isr32_handler() -> t.CExport | t.CVoid:
-    timer.timer_handler()
+export def isr0_handler():  isrCommonhandler(0)
+export def isr1_handler():  isrCommonhandler(1)
+export def isr2_handler():  isrCommonhandler(2)
+export def isr3_handler():  isrCommonhandler(3)
+export def isr4_handler():  isrCommonhandler(4)
+export def isr5_handler():  isrCommonhandler(5)
+export def isr6_handler():  isrCommonhandler(6)
+export def isr7_handler():  isrCommonhandler(7)
+export def isr8_handler():  isrCommonhandler(8)
+export def isr9_handler():  isrCommonhandler(9)
+export def isr10_handler(): isrCommonhandler(10)
+export def isr11_handler(): isrCommonhandler(11)
+export def isr12_handler(): isrCommonhandler(12)
+export def isr13_handler(): isrCommonhandler(13)
+export def isr14_handler(): isrCommonhandler(14)
+export def isr15_handler(): isrCommonhandler(15)
+export def isr16_handler(): isrCommonhandler(16)
+export def isr17_handler(): isrCommonhandler(17)
+export def isr18_handler(): isrCommonhandler(18)
+export def isr19_handler(): isrCommonhandler(19)
+export def isr20_handler(): isrCommonhandler(20)
+export def isr21_handler(): isrCommonhandler(21)
+export def isr22_handler(): isrCommonhandler(22)
+export def isr23_handler(): isrCommonhandler(23)
+export def isr24_handler(): isrCommonhandler(24)
+export def isr25_handler(): isrCommonhandler(25)
+export def isr26_handler(): isrCommonhandler(26)
+export def isr27_handler(): isrCommonhandler(27)
+export def isr28_handler(): isrCommonhandler(28)
+export def isr29_handler(): isrCommonhandler(29)
+export def isr30_handler(): isrCommonhandler(30)
+export def isr31_handler(): isrCommonhandler(31)
+export def isr32_handler(): timer.timer_handler()
 
-def isr33_handler() -> t.CExport | t.CVoid:
+export def isr33_handler():
     handler: irq_handler_t = irqGetHandler(1)
     if handler:
         c.Asm(f"""call {c.AsmInp(handler, t.ASM_DESCR.REG_ANY)}""",
@@ -331,7 +329,7 @@ def isr33_handler() -> t.CExport | t.CVoid:
     pic.eoi(1)
     apic.eoi()
 
-def isr34_handler() -> t.CExport | t.CVoid:
+export def isr34_handler():
     handler2: irq_handler_t = irqGetHandler(2)
     if handler2:
         c.Asm(f"""call {c.AsmInp(handler2, t.ASM_DESCR.REG_ANY)}""",
@@ -343,7 +341,7 @@ def isr34_handler() -> t.CExport | t.CVoid:
     pic.eoi(2)
     apic.eoi()
 
-def isr35_handler() -> t.CExport | t.CVoid:
+export def isr35_handler():
     handler3: irq_handler_t = irqGetHandler(3)
     if handler3:
         c.Asm(f"""call {c.AsmInp(handler3, t.ASM_DESCR.REG_ANY)}""",
@@ -355,7 +353,7 @@ def isr35_handler() -> t.CExport | t.CVoid:
     pic.eoi(3)
     apic.eoi()
 
-def isr36_handler() -> t.CExport | t.CVoid:
+export def isr36_handler():
     handler4: irq_handler_t = irqGetHandler(4)
     if handler4:
         c.Asm(f"""call {c.AsmInp(handler4, t.ASM_DESCR.REG_ANY)}""",
@@ -367,7 +365,7 @@ def isr36_handler() -> t.CExport | t.CVoid:
     pic.eoi(4)
     apic.eoi()
 
-def isr37_handler() -> t.CExport | t.CVoid:
+export def isr37_handler():
     handler5: irq_handler_t = irqGetHandler(5)
     if handler5:
         c.Asm(f"""call {c.AsmInp(handler5, t.ASM_DESCR.REG_ANY)}""",
@@ -379,7 +377,7 @@ def isr37_handler() -> t.CExport | t.CVoid:
     pic.eoi(5)
     apic.eoi()
 
-def isr38_handler() -> t.CExport | t.CVoid:
+export def isr38_handler():
     handler6: irq_handler_t = irqGetHandler(6)
     if handler6:
         c.Asm(f"""call {c.AsmInp(handler6, t.ASM_DESCR.REG_ANY)}""",
@@ -391,7 +389,7 @@ def isr38_handler() -> t.CExport | t.CVoid:
     pic.eoi(6)
     apic.eoi()
 
-def isr39_handler() -> t.CExport | t.CVoid:
+export def isr39_handler():
     if pic.isSpurious(7):
         return
     handler7: irq_handler_t = irqGetHandler(7)
@@ -405,7 +403,7 @@ def isr39_handler() -> t.CExport | t.CVoid:
     pic.eoi(7)
     apic.eoi()
 
-def isr40_handler() -> t.CExport | t.CVoid:
+export def isr40_handler():
     handler8: irq_handler_t = irqGetHandler(8)
     if handler8:
         c.Asm(f"""call {c.AsmInp(handler8, t.ASM_DESCR.REG_ANY)}""",
@@ -417,7 +415,7 @@ def isr40_handler() -> t.CExport | t.CVoid:
     pic.eoi(8)
     apic.eoi()
 
-def isr41_handler() -> t.CExport | t.CVoid:
+export def isr41_handler():
     handler9: irq_handler_t = irqGetHandler(9)
     if handler9:
         c.Asm(f"""call {c.AsmInp(handler9, t.ASM_DESCR.REG_ANY)}""",
@@ -429,7 +427,7 @@ def isr41_handler() -> t.CExport | t.CVoid:
     pic.eoi(9)
     apic.eoi()
 
-def isr42_handler() -> t.CExport | t.CVoid:
+export def isr42_handler():
     handler10: irq_handler_t = irqGetHandler(10)
     if handler10:
         c.Asm(f"""call {c.AsmInp(handler10, t.ASM_DESCR.REG_ANY)}""",
@@ -441,7 +439,7 @@ def isr42_handler() -> t.CExport | t.CVoid:
     pic.eoi(10)
     apic.eoi()
 
-def isr43_handler() -> t.CExport | t.CVoid:
+export def isr43_handler():
     handler11: irq_handler_t = irqGetHandler(11)
     if handler11:
         c.Asm(f"""call {c.AsmInp(handler11, t.ASM_DESCR.REG_ANY)}""",
@@ -452,7 +450,8 @@ def isr43_handler() -> t.CExport | t.CVoid:
                   t.ASM_DESCR.CLOBBER_R10, t.ASM_DESCR.CLOBBER_R11])
     pic.eoi(11)
     apic.eoi()
-def isr44_handler() -> t.CExport | t.CVoid:
+
+export def isr44_handler():
     handler: irq_handler_t = irqGetHandler(12)
     if handler:
         c.Asm(f"""call {c.AsmInp(handler, t.ASM_DESCR.REG_ANY)}""",
@@ -464,15 +463,15 @@ def isr44_handler() -> t.CExport | t.CVoid:
     pic.eoi(12)
     apic.eoi()
 
-def isr45_handler() -> t.CExport | t.CVoid:
+export def isr45_handler():
     pic.eoi(13)
     apic.eoi()
 
-def isr46_handler() -> t.CExport | t.CVoid:
+export def isr46_handler():
     pic.eoi(14)
     apic.eoi()
 
-def isr47_handler() -> t.CExport | t.CVoid:
+export def isr47_handler():
     if pic.isSpurious(15):
         return
     pic.eoi(15)
diff --git a/VKernel/Kernel/intr/syscall.vp b/VKernel/Kernel/intr/syscall.vp
index 0f4d149..7055664 100644
--- a/VKernel/Kernel/intr/syscall.vp
+++ b/VKernel/Kernel/intr/syscall.vp
@@ -85,7 +85,7 @@ def _fd_alloc(p: process.Process | t.CPtr) -> int:
 def _fd_free(p: process.Process | t.CPtr, fd: int):
     if fd >= 0 and fd < process.PROC_MAX_FDS:
         p.fd_used[fd] = 0
-        p.fd_table[fd] = t.CVoid(0, t.CPtr)
+        p.fd_table[fd] = t.CPtr(0)
 
 def _dir_alloc(p: process.Process | t.CPtr) -> int:
     for i in range(process.PROC_MAX_DIRS):
@@ -97,7 +97,7 @@ def _dir_alloc(p: process.Process | t.CPtr) -> int:
 def _dir_free(p: process.Process | t.CPtr, dd: int):
     if dd >= 0 and dd < process.PROC_MAX_DIRS:
         p.dir_used[dd] = 0
-        p.dir_table[dd] = t.CVoid(0, t.CPtr)
+        p.dir_table[dd] = t.CPtr(0)
 
 def CREATE_WINDOW(x: int, y: int, w: int, h: int, title: t.CConst | t.CChar | t.CPtr, style: int) -> int:
     desktop.set_app_pid(process.current())
@@ -116,17 +116,17 @@ def WAIT_WINDOW(win_id: int) -> int:
         sched.Scheduler.try_reschedule()
     return 0
 
-def SERIAL_PUTS(str_ptr: t.CPtr) -> int:
-    s: t.CConst | t.CChar | t.CPtr = t.CVoid(str_ptr, t.CPtr)
+def SERIAL_PUTS(str_ptr: str) -> int:
+    s: t.CConst | str = str_ptr
     serial.puts(s)
     return 0
 
 _loaded_so_base: t.CPtr = None
 _loaded_so_path: t.CArray[t.CChar, 64]
 
-def LOAD_SO(path_ptr: t.CPtr) -> uint64:
+def LOAD_SO(path_ptr: str) -> uint64:
     global _loaded_so_base
-    path: t.CConst | t.CChar | t.CPtr = t.CVoid(path_ptr, t.CPtr)
+    path: t.CConst | str = path_ptr
     serial.puts("[so] loading: ")
     serial.puts(path)
     serial.puts("\n")
@@ -141,9 +141,9 @@ def LOAD_SO(path_ptr: t.CPtr) -> uint64:
         return uint64(base)
     return 0
 
-def SO_CALL1(sym_name_ptr: t.CPtr, arg1: t.CPtr) -> int:
+def SO_CALL1(sym_name_ptr: str, arg1: t.CPtr) -> int:
     if _loaded_so_base is None: return -1
-    sym_name: t.CConst | t.CChar | t.CPtr = t.CVoid(sym_name_ptr, t.CPtr)
+    sym_name: t.CConst | str = t.CPtr(sym_name_ptr)
     fn: t.CPtr = elf.get_so_symbol(_loaded_so_base, sym_name, c.Addr(_loaded_so_path[0]))
     if fn is None:
         serial.puts("[so] symbol not found\n")
@@ -172,9 +172,9 @@ def SET_CURSOR(win_id: int, cursor_t: int) -> int:
     desktop.set_cursor_type(win_id, cursor_t)
     return 0
 
-def OPEN(path_ptr: t.CPtr, mode: uint32) -> int:
+def OPEN(path_ptr: str, mode: uint32) -> int:
     p: process.Process | t.CPtr = _current_proc()
-    path: t.CConst | t.CChar | t.CPtr = t.CVoid(path_ptr, t.CPtr)
+    path: t.CConst | str = path_ptr
     fat32.lock()
     fp: t.CPtr = fat32.open(path, uint8(mode))
     if not fp:
@@ -262,23 +262,23 @@ def fsize(fd: int) -> uint32:
     fat32.unlock()
     return sz
 
-def MKDIR(path_ptr: t.CPtr) -> int:
-    path: t.CConst | t.CChar | t.CPtr = t.CVoid(path_ptr, t.CPtr)
+def MKDIR(path_ptr: str) -> int:
+    path: t.CConst | str = path_ptr
     fat32.lock()
     r: int = int(fat32.mkdir(path))
     fat32.unlock()
     return r
 
-def REMOVE(path_ptr: t.CPtr) -> int:
-    path: t.CConst | t.CChar | t.CPtr = t.CVoid(path_ptr, t.CPtr)
+def REMOVE(path_ptr: str) -> int:
+    path: t.CConst | str = path_ptr
     fat32.lock()
     r: int = int(fat32.remove(path))
     fat32.unlock()
     return r
 
-def OPENdir(path_ptr: t.CPtr) -> int:
+def OPENdir(path_ptr: str) -> int:
     p: process.Process | t.CPtr = _current_proc()
-    path: t.CConst | t.CChar | t.CPtr = t.CVoid(path_ptr, t.CPtr)
+    path: t.CConst | str = path_ptr
     dd: int = _dir_alloc(p)
     if dd < 0:
         return -1
@@ -289,7 +289,7 @@ def OPENdir(path_ptr: t.CPtr) -> int:
     if res != 0:
         _dir_free(p, dd)
         return -1
-    p.dir_table[dd] = t.CVoid(uint64(dp), t.CPtr)
+    p.dir_table[dd] = t.CPtr(uint64(dp))
     return dd
 
 def READdir(dd: int, info_ptr: t.CPtr) -> int:
@@ -318,16 +318,16 @@ def CLOSEdir(dd: int) -> int:
     _dir_free(p, dd)
     return 0
 
-def STAT(path_ptr: t.CPtr, info_ptr: t.CPtr) -> int:
-    path: t.CConst | t.CChar | t.CPtr = t.CVoid(path_ptr, t.CPtr)
+def STAT(path_ptr: str, info_ptr: t.CPtr) -> int:
+    path: t.CConst | str = path_ptr
     info: fat32_types.fileinfo | t.CPtr = info_ptr
     fat32.lock()
     r: int = int(fat32.stat(path, info))
     fat32.unlock()
     return r
 
-def SPAWN(path_ptr: t.CPtr, blocking: int) -> int:
-    path: t.CConst | t.CChar | t.CPtr = t.CVoid(path_ptr, t.CPtr)
+def SPAWN(path_ptr: str, blocking: int) -> int:
+    path: t.CConst | str = path_ptr
     pid: int = elf.spawn_elf(path)
     if pid < 0:
         return pid
@@ -358,28 +358,28 @@ def MMAP(size: uint64) -> uint64:
 def MUNMAP(ptr: uint64, size: uint64) -> int:
     return 0
 
-def syscall_entry() -> t.CExtern | t.CVoid | t.State: pass
+extern def syscall_entry(): pass
 
 def syscall_handler(num: uint64, arg1: uint64, arg2: uint64, arg3: uint64, arg4: uint64, arg5: uint64, arg6: uint64) -> t.CExport | uint64:
     n: int = int(num)
     if n == CREATE_WINDOW:
-        title_ptr: t.CPtr = t.CVoid(arg5, t.CPtr)
+        title_ptr: str = str(arg5)
         return uint64(CREATE_WINDOW(int(arg1), int(arg2), int(arg3), int(arg4), title_ptr, int(arg6)))
     elif n == DRAW_TEXT:
-        text_ptr: t.CPtr = t.CVoid(arg4, t.CPtr)
+        text_ptr: str = str(arg4)
         return uint64(DRAW_TEXT(int(arg1), int(arg2), int(arg3), text_ptr, uint32(arg5)))
     elif n == EXIT:
         return uint64(EXIT(int(arg1)))
     elif n == OPEN:
-        path_ptr: t.CPtr = t.CVoid(arg1, t.CPtr)
+        path_ptr: str = str(arg1)
         return uint64(OPEN(path_ptr, uint32(arg2)))
     elif n == CLOSE:
         return uint64(CLOSE(int(arg1)))
     elif n == READ:
-        buf_ptr: t.CPtr = t.CVoid(arg2, t.CPtr)
+        buf_ptr: t.CPtr = t.CPtr(arg2)
         return uint64(READ(int(arg1), buf_ptr, uint32(arg3)))
     elif n == WRITE:
-        buf_ptr: t.CPtr = t.CVoid(arg2, t.CPtr)
+        buf_ptr: t.CPtr = t.CPtr(arg2)
         return uint64(WRITE(int(arg1), buf_ptr, uint32(arg3)))
     elif n == SEEK:
         return uint64(SEEK(int(arg1), uint32(arg2)))
@@ -388,22 +388,22 @@ def syscall_handler(num: uint64, arg1: uint64, arg2: uint64, arg3: uint64, arg4:
     elif n == SIZE:
         return uint64(fsize(int(arg1)))
     elif n == MKDIR:
-        path_ptr: t.CPtr = t.CVoid(arg1, t.CPtr)
+        path_ptr: str = str(arg1)
         return uint64(MKDIR(path_ptr))
     elif n == REMOVE:
-        path_ptr: t.CPtr = t.CVoid(arg1, t.CPtr)
+        path_ptr: str = str(arg1)
         return uint64(REMOVE(path_ptr))
     elif n == OPENDIR:
-        path_ptr: t.CPtr = t.CVoid(arg1, t.CPtr)
+        path_ptr: str = str(arg1)
         return uint64(OPENdir(path_ptr))
     elif n == READDIR:
-        info_ptr: t.CPtr = t.CVoid(arg2, t.CPtr)
+        info_ptr: t.CPtr = t.CPtr(arg2)
         return uint64(READdir(int(arg1), info_ptr))
     elif n == CLOSEDIR:
         return uint64(CLOSEdir(int(arg1)))
     elif n == STAT:
-        path_ptr: t.CPtr = t.CVoid(arg1, t.CPtr)
-        info_ptr: t.CPtr = t.CVoid(arg2, t.CPtr)
+        path_ptr: str = str(arg1)
+        info_ptr: t.CPtr = t.CPtr(arg2)
         return uint64(STAT(path_ptr, info_ptr))
     elif n == WAIT_WINDOW:
         if int(arg2) == 1:
@@ -413,20 +413,20 @@ def syscall_handler(num: uint64, arg1: uint64, arg2: uint64, arg3: uint64, arg4:
             return 0
         return uint64(WAIT_WINDOW(int(arg1)))
     elif n == SERIAL_PUTS:
-        str_ptr_sp: t.CPtr = t.CVoid(arg1, t.CPtr)
+        str_ptr_sp: str = str(arg1)
         return uint64(SERIAL_PUTS(str_ptr_sp))
     elif n == LOAD_SO:
-        path_ptr_so: t.CPtr = t.CVoid(arg1, t.CPtr)
+        path_ptr_so: t.CPtr = t.CPtr(arg1)
         return LOAD_SO(path_ptr_so)
     elif n == SO_CALL1:
-        sym_ptr: t.CPtr = t.CVoid(arg1, t.CPtr)
+        sym_ptr: t.CPtr = t.CPtr(arg1)
         return uint64(SO_CALL1(sym_ptr, t.CPtr(arg2)))
     elif n == GET_WINBUF:
         return GET_WINBUF(int(arg1))
     elif n == WIN_FLUSH:
         return uint64(WIN_FLUSH(int(arg1)))
     elif n == POLL_EVENT:
-        buf_ptr_ev: t.CPtr = t.CVoid(arg1, t.CPtr)
+        buf_ptr_ev: t.CPtr = t.CPtr(arg1)
         caller_pid_ev: int = process.current()
         return uint64(desktop.poll_event(buf_ptr_ev, caller_pid_ev))
     elif n == SET_CURSOR:
@@ -436,7 +436,7 @@ def syscall_handler(num: uint64, arg1: uint64, arg2: uint64, arg3: uint64, arg4:
         sched.Scheduler.try_reschedule()
         return 0
     elif n == SET_TITLE:
-        title_ptr_st: t.CPtr = t.CVoid(arg2, t.CPtr)
+        title_ptr_st: t.CPtr = t.CPtr(arg2)
         return uint64(desktop.set_title(int(arg1), title_ptr_st))
     elif n == SET_GEOMETRY:
         return uint64(desktop.set_geometry(int(arg1), int(arg2), int(arg3), int(arg4), int(arg5)))
@@ -445,15 +445,15 @@ def syscall_handler(num: uint64, arg1: uint64, arg2: uint64, arg3: uint64, arg4:
     elif n == GET_WIN_SIZE:
         return uint64(desktop.get_size(int(arg1)))
     elif n == SPAWN:
-        path_ptr_sp: t.CPtr = t.CVoid(arg1, t.CPtr)
+        path_ptr_sp: t.CPtr = t.CPtr(arg1)
         return uint64(SPAWN(path_ptr_sp, int(arg2)))
     elif n == MMAP:
         return MMAP(arg1)
     elif n == MUNMAP:
         return uint64(MUNMAP(arg1, arg2))
     elif n == THREAD_CREATE:
-        func_ptr: t.CPtr = t.CVoid(arg1, t.CPtr)
-        arg_ptr: t.CPtr = t.CVoid(arg2, t.CPtr)
+        func_ptr: t.CPtr = t.CPtr(arg1)
+        arg_ptr: t.CPtr = t.CPtr(arg2)
         cur_pid: int = process.current()
         th: sched.Thread | t.CPtr = sched.Scheduler.create_thread(func_ptr, arg_ptr, cur_pid)
         if th is None: return uint64(0xFFFFFFFFFFFFFFFF)
diff --git a/VKernel/Kernel/mm/mm.vp b/VKernel/Kernel/mm/mm.vp
index 20a9b1f..91586aa 100644
--- a/VKernel/Kernel/mm/mm.vp
+++ b/VKernel/Kernel/mm/mm.vp
@@ -103,7 +103,7 @@ class _BuddySystemObject:
         self.buddy.used_memory = 0
         self.buddy.free_memory = size
         self.buddy.start_addr = start_addr
-        self.buddy.end_addr = t.CVoid(uint64(start_addr) + size, t.CPtr)
+        self.buddy.end_addr = t.CPtr(uint64(start_addr) + size)
         remaining: uint64 = size
         cur_addr: uint64 = uint64(start_addr)
         # [DBG] buddy 初始化循环进度（用后移除）
@@ -254,7 +254,7 @@ class _BuddySystemObject:
         return block
 
     # 释放内存块
-    def free_block(self, block: memory_block | t.CPtr) -> t.CStatic | t.CVoid:
+    def free_block(self, block: memory_block | t.CPtr):
         # 标记块为空闲
         block.state = BLOCK_FREE
         # 更新内存统计
@@ -345,13 +345,13 @@ class _SlabAllocator:
         page.next = None
         page.prev = None
         data_start: uint64 = uint64(block) + d_off
-        page.free_head = t.CVoid(data_start, t.CPtr)
+        page.free_head = t.CPtr(data_start)
         for i in range(1, total):
-            cur: t.CPtr = t.CVoid(data_start + uint64(i - 1) * aligned_size, t.CPtr)
-            nxt: t.CPtr = t.CVoid(data_start + uint64(i) * aligned_size, t.CPtr)
+            cur: t.CPtr = t.CPtr(data_start + uint64(i - 1) * aligned_size)
+            nxt: t.CPtr = t.CPtr(data_start + uint64(i) * aligned_size)
             _slab_write_ptr(cur, nxt)
-        last: t.CPtr = t.CVoid(data_start + uint64(total - 1) * aligned_size, t.CPtr)
-        _slab_write_ptr(last, t.CVoid(0, t.CPtr))
+        last: t.CPtr = t.CPtr(data_start + uint64(total - 1) * aligned_size)
+        _slab_write_ptr(last, t.CPtr(0))
         return page
 
     def alloc(self, size_class: int) -> t.CPtr:
@@ -413,18 +413,18 @@ def malloc(size: uint64) -> t.CPtr | t.CExport:
         user_ptr: uint64 = (uint64(block) + hdr + 4095) & ~uint64(4095)
         real_hdr: uint64 = user_ptr - 8
         c.Asm(f"""mov rax, {c.AsmInp(block, t.ASM_DESCR.REG_ANY)}
-                  mov [{c.AsmInp(t.CVoid(real_hdr, t.CPtr), t.ASM_DESCR.REG_ANY)}], rax""",
+                  mov [{c.AsmInp(t.CPtr(real_hdr), t.ASM_DESCR.REG_ANY)}], rax""",
               op=[t.ASM_DESCR.CLOBBER_RAX, t.ASM_DESCR.CLOBBER_MEMORY])
         viperlib.snprintf(c.Addr(_dbm), 120, "[mm] malloc ret user_ptr=0x%lx\n", user_ptr)
         serial.puts(_dbm)
-        return t.CVoid(user_ptr, t.CPtr)
+        return t.CPtr(user_ptr)
     total2: uint64 = size + hdr
     total2 = align_4k(total2)
     order2: int = get_order(total2)
     if order2 > MAX_ORDER: return None
     block2: memory_block | t.CPtr = BuddySystemObject.allocate_block(total2)
     if not block2: return None
-    return t.CVoid(uint64(block2) + hdr, t.CPtr)
+    return t.CPtr(uint64(block2) + hdr)
 
 
 def malloc_direct(size: uint64) -> t.CPtr | t.CExport:
@@ -436,7 +436,7 @@ def malloc_direct(size: uint64) -> t.CPtr | t.CExport:
     if order > MAX_ORDER: return None
     block: memory_block | t.CPtr = BuddySystemObject.allocate_block(total)
     if not block: return None
-    return t.CVoid(uint64(block) + hdr, t.CPtr)
+    return t.CPtr(uint64(block) + hdr)
 
 
 def free(ptr: t.CPtr) -> t.CExport:
@@ -448,7 +448,7 @@ def free(ptr: t.CPtr) -> t.CExport:
     if (uint64(ptr) & 0xFFF) == 0:
         real_hdr: uint64 = uint64(ptr) - 8
         block: memory_block | t.CPtr
-        c.Asm(f"""mov rax, [{c.AsmInp(t.CVoid(real_hdr, t.CPtr), t.ASM_DESCR.REG_ANY)}]
+        c.Asm(f"""mov rax, [{c.AsmInp(t.CPtr(real_hdr), t.ASM_DESCR.REG_ANY)}]
                   mov {c.AsmOut(block, t.ASM_DESCR.OUTPUT_REG)}, rax""",
               op=[t.ASM_DESCR.CLOBBER_MEMORY, t.ASM_DESCR.CLOBBER_RAX])
         BuddySystemObject.free_block(block)
@@ -476,7 +476,7 @@ def realloc(ptr: t.CPtr, size: uint64) -> t.CPtr | t.CExport:
     elif (uint64(ptr) & 0xFFF) == 0:
         real_hdr_r: uint64 = uint64(ptr) - 8
         block_r: memory_block | t.CPtr
-        c.Asm(f"""mov rax, [{c.AsmInp(t.CVoid(real_hdr_r, t.CPtr), t.ASM_DESCR.REG_ANY)}]
+        c.Asm(f"""mov rax, [{c.AsmInp(t.CPtr(real_hdr_r), t.ASM_DESCR.REG_ANY)}]
                   mov {c.AsmOut(block_r, t.ASM_DESCR.OUTPUT_REG)}, rax""",
               op=[t.ASM_DESCR.CLOBBER_MEMORY, t.ASM_DESCR.CLOBBER_RAX])
         old_size = block_r.size - 4096
@@ -490,7 +490,7 @@ def realloc(ptr: t.CPtr, size: uint64) -> t.CPtr | t.CExport:
 
 
 # 回收内存区域链表
-def free_memory_regions() -> t.CStatic | t.CVoid:
+def free_memory_regions():
     global memory_regions
     current: memory_region | t.CPtr = memory_regions
     while current:
@@ -530,13 +530,13 @@ def init(MemmapAddr: uint64, MemmapSize: uint64, MemmapDescSize: uint64, FbAddr:
                 i: uint64
                 # [DBG] 转储全部 memmap 描述符，定位 4GB 伪可用区的来源（用后移除）
                 for i in range(num_entries):
-                    entry: bootinfo.memory_map_entry | t.CPtr = t.CVoid(MemmapAddr + i * MemmapDescSize, t.CPtr)
+                    entry: bootinfo.memory_map_entry | t.CPtr = t.CPtr(MemmapAddr + i * MemmapDescSize)
                     _dbgd: t.CArray[t.CChar, 100]
                     viperlib.snprintf(c.Addr(_dbgd), 100, "[mm] d[%lu] t=%lu start=0x%lx np=%lu\n",
                                       i, uint64(entry.type), entry.physical_start, entry.num_pages)
                     serial.puts(c.Addr(_dbgd))
                 for i in range(num_entries):
-                    entry: bootinfo.memory_map_entry | t.CPtr = t.CVoid(MemmapAddr + i * MemmapDescSize, t.CPtr)
+                    entry: bootinfo.memory_map_entry | t.CPtr = t.CPtr(MemmapAddr + i * MemmapDescSize)
                     etype: uint64 = entry.type
                     start: uint64 = align_4k(entry.physical_start)
                     np: uint64 = entry.num_pages
@@ -576,7 +576,7 @@ def init(MemmapAddr: uint64, MemmapSize: uint64, MemmapDescSize: uint64, FbAddr:
                 serial.puts(cr4)
                 if best_start != 0:
                     if max_memory >= min_blk:
-                        start_addr = t.CVoid(best_start, t.CPtr)
+                        start_addr = t.CPtr(best_start)
                         size = max_memory
     if start_addr is None:
         # [DBG] fallback：打印 detect_memory_size 与 CMOS 原始值（用后移除）
@@ -591,7 +591,7 @@ def init(MemmapAddr: uint64, MemmapSize: uint64, MemmapDescSize: uint64, FbAddr:
         size = align_4k(size)
         # 起始地址 4MB（内核之后），避免超出物理 RAM
         # 旧值 0x10000000 在 256MB QEMU 中超出物理 RAM 边界
-        start_addr = t.CVoid(align_4k(0x400000), t.CPtr)
+        start_addr = t.CPtr(align_4k(0x400000))
         if size > 0x400000:
             size = size - 0x400000
         size = align_4k(size)
@@ -752,7 +752,7 @@ def vm_free(VirtAddr: uint64):
                 paging.UnMapPage(page_virt)
 
             # 释放物理内存
-            free(t.CVoid(current.PhysAddr, t.CPtr))
+            free(t.CPtr(current.PhysAddr))
             if prev:
                 prev.next = current.next
             else:
diff --git a/VKernel/Kernel/paging/paging.vp b/VKernel/Kernel/paging/paging.vp
index d2656c4..dc71a7b 100644
--- a/VKernel/Kernel/paging/paging.vp
+++ b/VKernel/Kernel/paging/paging.vp
@@ -63,7 +63,7 @@ def AllocPage() -> t.CPtr:
     global AllocatedPages, pt_pool_used, pml4, pdp, pd, pt
     if pt_pool_raw is None: return None
     if pt_pool_used >= uint64(PT_POOL_PAGES): return None
-    page: t.CPtr = t.CVoid(pt_pool_start + pt_pool_used * uint64(4096), t.CPtr)
+    page: t.CPtr = t.CPtr(pt_pool_start + pt_pool_used * uint64(4096))
     pt_pool_used = pt_pool_used + uint64(1)
     # rep stosb 向 [rdi] 写 4096 字节：必须声明 CLOBBER_MEMORY，否则优化器
     # 无法得知本块改写了内存，可能把其前后的内存读写重排/消除（N8）。
@@ -139,7 +139,7 @@ def MapPage(VirtAddr: uint64, PhysAddr: uint64, flags: uint64):
     pt.entries[PtIndex] = PhysAddr | flags | PTE_PRESENT
     c.Asm(f"invlpg [{c.AsmInp(VirtAddr, t.ASM_DESCR.REG_ANY)}]")
 
-def MapLargePage(VirtAddr: uint64, PhysAddr: uint64, flags: uint64) -> t.CVoid:
+def MapLargePage(VirtAddr: uint64, PhysAddr: uint64, flags: uint64):
     global pml4, pdp, pd, pt
     VirtAddr = VirtAddr & ~uint64(0x1FFFFF)
     PhysAddr = PhysAddr & ~uint64(0x1FFFFF)
diff --git a/VKernel/Kernel/sched/process.vp b/VKernel/Kernel/sched/process.vp
index add8276..8657169 100644
--- a/VKernel/Kernel/sched/process.vp
+++ b/VKernel/Kernel/sched/process.vp
@@ -55,14 +55,14 @@ class Process:
                 if fp:
                     fat32.close(fp)
                 self.fd_used[i] = 0
-                self.fd_table[i] = t.CVoid(0, t.CPtr)
+                self.fd_table[i] = None
         for i in range(PROC_MAX_DIRS):
             if self.dir_used[i]:
                 dp: t.CPtr = self.dir_table[i]
                 if dp:
                     fat32.closedir(dp)
                 self.dir_used[i] = 0
-                self.dir_table[i] = t.CVoid(0, t.CPtr)
+                self.dir_table[i] = None
         m: ProcessManager | t.CPtr = _proc_mgr_ptr
         if m.current_pid == self.pid:
             m.current_pid = 0
@@ -120,10 +120,10 @@ class ProcessManager:
             p.threads[j] = -1
         for j in range(PROC_MAX_FDS):
             p.fd_used[j] = 0
-            p.fd_table[j] = t.CVoid(0, t.CPtr)
+            p.fd_table[j] = None
         for j in range(PROC_MAX_DIRS):
             p.dir_used[j] = 0
-            p.dir_table[j] = t.CVoid(0, t.CPtr)
+            p.dir_table[j] = None
         c.Asm(f"""mov {c.AsmOut(p.pml4_root, t.ASM_DESCR.OUTPUT_REG)}, cr3""",
             op=[t.ASM_DESCR.CLOBBER_MEMORY])
 
@@ -186,10 +186,10 @@ class ProcessManager:
             p.threads[j] = -1
         for j in range(PROC_MAX_FDS):
             p.fd_used[j] = 0
-            p.fd_table[j] = t.CVoid(0, t.CPtr)
+            p.fd_table[j] = None
         for j in range(PROC_MAX_DIRS):
             p.dir_used[j] = 0
-            p.dir_table[j] = t.CVoid(0, t.CPtr)
+            p.dir_table[j] = None
         ks: t.CPtr = mm.malloc(KERN_STACK_SIZE)
         # [DIAG] 定位跨模块 malloc 返回值（mm 成功但调用方收到 None）
         _dbg_ks: t.CArray[t.CChar, 64]
diff --git a/VKernel/Kernel/services/desktop.vp b/VKernel/Kernel/services/desktop.vp
index 093b949..1d58d03 100644
--- a/VKernel/Kernel/services/desktop.vp
+++ b/VKernel/Kernel/services/desktop.vp
@@ -452,7 +452,7 @@ def _fill_rect(buf: UINT32PTR, bw: int, bh: int, rx: int, ry: int, rw: int, rh:
             _row_buf[i] = color
         row_bytes: int = rw * 4
         for py in range(ry, ry + rh):
-            string.memcpy(t.CVoid(uint64(buf) + (py * bw + rx) * 4, t.CPtr), _row_buf, row_bytes)
+            string.memcpy(t.CPtr(uint64(buf) + (py * bw + rx) * 4), _row_buf, row_bytes)
 
 def _alpha_blend(bg: uint32, fg: uint32, alpha: int) -> uint32:
     a: int = alpha
@@ -1310,7 +1310,7 @@ def _render():
         py_bg: int = _dirty_y_min
         while py_bg <= _dirty_y_max:
             if _dirty_rows[py_bg]:
-                string.memcpy(t.CVoid(uint64(back) + py_bg * row_bytes, t.CPtr), _bg_row_buf, row_bytes)
+                string.memcpy(t.CPtr(uint64(back) + py_bg * row_bytes), _bg_row_buf, row_bytes)
             py_bg += 1
     t1: uint64 = timer.timer_get_ticks()
     _perf_t_bg += (t1 - t0)
@@ -1353,7 +1353,7 @@ def _render():
                 while py_fb <= _dirty_y_max and _dirty_rows[py_fb]:
                     py_fb += 1
                 run_bytes: int = (py_fb - run_start) * row_bytes
-                string.memcpy(t.CVoid(uint64(_fb) + run_start * pitch, t.CPtr), t.CVoid(uint64(back) + run_start * row_bytes, t.CPtr), run_bytes)
+                string.memcpy(t.CPtr(uint64(_fb) + run_start * pitch), t.CPtr(uint64(back) + run_start * row_bytes), run_bytes)
             else:
                 py_fb += 1
     t5: uint64 = timer.timer_get_ticks()
@@ -2375,7 +2375,7 @@ def _draw_app_window(back: UINT32PTR, win: AppWindow | t.CPtr):
         fb_stride: int = win.fb_w
         fbh: int = win.fb_h
         if fb_stride <= 0 or fbh <= 0:
-            win_fb = t.CVoid(0, t.CPtr)
+            win_fb = None
         if win_fb:
             draw_rows: int = ch
             if draw_rows > fbh: draw_rows = fbh
@@ -2402,7 +2402,7 @@ def _draw_app_window(back: UINT32PTR, win: AppWindow | t.CPtr):
                         if actual_w <= 0: continue
                         src_off: int = row * fb_stride + src_x
                         if src_off + actual_w > fb_total: continue
-                        string.memcpy(t.CVoid(uint64(back) + (dst_y * w + dst_x) * 4, t.CPtr), t.CVoid(uint64(win_fb) + src_off * 4, t.CPtr), actual_w * 4)
+                        string.memcpy(t.CPtr(uint64(back) + (dst_y * w + dst_x) * 4), t.CPtr(uint64(win_fb) + src_off * 4), actual_w * 4)
                     else:
                         copy_w: int = fb_stride - 1
                         if copy_w > ww - 1: copy_w = ww - 1
@@ -2438,7 +2438,7 @@ def _draw_app_window(back: UINT32PTR, win: AppWindow | t.CPtr):
                     if actual_w2 <= 0: continue
                     src_off2: int = row * fb_stride + src_x2
                     if src_off2 + actual_w2 > fb_total: continue
-                    string.memcpy(t.CVoid(uint64(back) + (dst_y * w + dst_x3) * 4, t.CPtr), t.CVoid(uint64(win_fb) + src_off2 * 4, t.CPtr), actual_w2 * 4)
+                    string.memcpy(t.CPtr(uint64(back) + (dst_y * w + dst_x3) * 4), t.CPtr(uint64(win_fb) + src_off2 * 4), actual_w2 * 4)
 
     btn_w: int = CLOSE_BTN_SIZE
     btn_h: int = CLOSE_BTN_SIZE
@@ -2508,7 +2508,7 @@ def create(x: int, y: int, w: int, h: int, title: t.CConst | t.CChar | t.CPtr, s
     aw.app_cursor_type = 0
     aw.fb_w = 0
     aw.fb_h = 0
-    aw.old_fb = t.CVoid(0, t.CPtr)
+    aw.old_fb = None
     aw.ping_pending = 0
     aw.no_resp = 0
     aw.no_resp_sec = 0
@@ -2557,12 +2557,12 @@ def is_active(win_id: int) -> int:
     return _wins[win_id].active
 
 def get_fb(win_id: int) -> UINT32PTR:
-    if win_id < 0 or win_id >= _win_count: return t.CVoid(0, t.CPtr)
+    if win_id < 0 or win_id >= _win_count: return None
     aw: AppWindow | t.CPtr = c.Addr(_wins[win_id])
-    if not aw.active: return t.CVoid(0, t.CPtr)
+    if not aw.active: return None
     if aw.old_fb:
         mm.free(aw.old_fb)
-        aw.old_fb = t.CVoid(0, t.CPtr)
+        aw.old_fb = None
     if aw.resize_w != 0 and (aw.fb_w != aw.resize_w or aw.fb_h != aw.resize_h):
         target_w: int = aw.resize_w
         target_h: int = aw.resize_h
@@ -2595,7 +2595,7 @@ def get_fb(win_id: int) -> UINT32PTR:
             for ri_gf in range(cph_gf):
                 rb_gf: int = old_fbw_gf
                 if rb_gf > target_w: rb_gf = target_w
-                string.memcpy(t.CVoid(uint64(aw.fb) + ri_gf * target_w * 4, t.CPtr), t.CVoid(uint64(old_fb_gf) + ri_gf * old_fbw_gf * 4, t.CPtr), rb_gf * 4)
+                string.memcpy(t.CPtr(uint64(aw.fb) + ri_gf * target_w * 4), t.CPtr(uint64(old_fb_gf) + ri_gf * old_fbw_gf * 4), rb_gf * 4)
             if aw.old_fb:
                 mm.free(aw.old_fb)
             aw.old_fb = old_fb_gf
@@ -2674,7 +2674,7 @@ def flush(win_id: int):
     if not aw.active: return
     if aw.old_fb:
         mm.free(aw.old_fb)
-        aw.old_fb = t.CVoid(0, t.CPtr)
+        aw.old_fb = None
     if aw.ping_pending:
         aw.ping_pending = 0
         if aw.no_resp:
diff --git a/vpsdk/process.vp b/vpsdk/process.vp
index e4cd13a..32acefd 100644
--- a/vpsdk/process.vp
+++ b/vpsdk/process.vp
@@ -1,10 +1,10 @@
 import t, c
 from . import syscall as syscall
 
-def exit(code: int) -> t.CVoid:
+def exit(code: int):
     syscall._syscall1(uint64(syscall.EXIT), uint64(code))
 
-def yield_cpu() -> t.CVoid:
+def yield_cpu():
     syscall._syscall2(uint64(syscall.WAIT_WINDOW), uint64(0), uint64(2))
 
 def spawn(path: t.CConst | t.CChar | t.CPtr, blocking: int = 0) -> int:
diff --git a/vpsdk/stdio.vp b/vpsdk/stdio.vp
index a36026d..db159f5 100644
--- a/vpsdk/stdio.vp
+++ b/vpsdk/stdio.vp
@@ -10,7 +10,7 @@ import viperlib
 # syscall 输出到串口；exit 走 EXIT syscall 通知内核销毁本进程窗口。
 # ============================================================
 
-def printf(fmt: t.CConst | str, *args) -> int | t.CExport:
+export def printf(fmt: t.CConst | str, *args) -> int:
     """格式化输出到串口（SERIAL_PUTS syscall），返回输出字节数"""
     if fmt is None:
         return 0
@@ -19,12 +19,12 @@ def printf(fmt: t.CConst | str, *args) -> int | t.CExport:
     _syscall._syscall1(uint64(_syscall.SERIAL_PUTS), uint64(c.Addr(buf)))
     return n
 
-def exit(status: int) -> t.CVoid | t.CExport:
+export def exit(status: int):
     """终止当前进程（EXIT syscall：销毁本进程窗口）"""
     _syscall._syscall1(uint64(_syscall.EXIT), uint64(status))
 
 
-def fflush(stream: t.CConst | t.CPtr) -> int | t.CExport:
+export def fflush(stream: t.CConst | t.CPtr) -> int:
     """刷新输出流：串口/控制台输出都是直写，无缓冲可刷，空操作返回 0
 
     覆盖 libc fflush 的裸机缺失（includes/memhub.vp 的诊断/终止路径 call @fflush）；
diff --git a/vpsdk/stdlib.vp b/vpsdk/stdlib.vp
index 6118d55..d088b26 100644
--- a/vpsdk/stdlib.vp
+++ b/vpsdk/stdlib.vp
@@ -24,15 +24,15 @@ def malloc(size: t.CSizeT) -> t.CPtr | t.CExport:
     total: t.CSizeT = hdr_size + size
     ptr: uint64 = _sc._syscall1(uint64(_sc.SYSCALL_MMAP), uint64(total))
     if ptr == 0: return None
-    hdr: _heap_hdr | t.CPtr = t.CVoid(ptr, t.CPtr)
+    hdr: _heap_hdr | t.CPtr = t.CPtr(ptr)
     hdr.magic = HEAP_BLOCK_MAGIC
     hdr.size = uint32(size)
-    return t.CVoid(ptr + hdr_size, t.CPtr)
+    return t.CPtr(ptr + hdr_size)
 
 def free(ptr: t.CPtr) -> t.CExport:
     if ptr is None: return
     hdr_size: t.CSizeT = _heap_hdr.__sizeof__()
-    hdr: _heap_hdr | t.CPtr = t.CVoid(uint64(ptr) - hdr_size, t.CPtr)
+    hdr: _heap_hdr | t.CPtr = t.CPtr(uint64(ptr) - hdr_size)
     if hdr.magic != HEAP_BLOCK_MAGIC: return
 
 def calloc(nmemb: t.CSizeT, size: t.CSizeT) -> t.CPtr | t.CExport:
@@ -48,7 +48,7 @@ def realloc(ptr: t.CPtr, size: t.CSizeT) -> t.CPtr | t.CExport:
         free(ptr)
         return None
     hdr_size: t.CSizeT = _heap_hdr.__sizeof__()
-    hdr: _heap_hdr | t.CPtr = t.CVoid(uint64(ptr) - hdr_size, t.CPtr)
+    hdr: _heap_hdr | t.CPtr = t.CPtr(uint64(ptr) - hdr_size)
     if hdr.magic != HEAP_BLOCK_MAGIC: return None
     old_size: t.CSizeT = hdr.size
     new_ptr: t.CPtr = malloc(size)
diff --git a/vpsdk/vpui.vp b/vpsdk/vpui.vp
index f315790..7d93d56 100644
--- a/vpsdk/vpui.vp
+++ b/vpsdk/vpui.vp
@@ -54,10 +54,10 @@ _g_layout_init: int
 _hex_tbl: t.CArray[t.CChar, 17] = "0123456789ABCDEF"
 _hex_buf: t.CArray[t.CChar, 20] = "0000000000000000000"
 
-def _serial_puts(s: t.CConst | t.CChar | t.CPtr) -> t.CVoid:
+def _serial_puts(s: t.CConst | t.CChar | t.CPtr):
     _syscall._syscall1(uint64(_syscall.SERIAL_PUTS), uint64(s))
 
-def _ptr_to_hex(val: uint64, buf: t.CPtr) -> t.CVoid:
+def _ptr_to_hex(val: uint64, buf: t.CPtr):
     buf[0] = 48
     buf[1] = 120
     i: int = 15
diff --git a/vpsdk/window.vp b/vpsdk/window.vp
index a669f48..ad99953 100644
--- a/vpsdk/window.vp
+++ b/vpsdk/window.vp
@@ -57,15 +57,15 @@ def draw_text(win_id: int, x: int, y: int, text: t.CConst | t.CChar | t.CPtr, co
     return int(syscall._syscall5(uint64(syscall.DRAW_TEXT), uint64(win_id), uint64(x), uint64(y), uint64(text), uint64(color)))
 
 def get_winbuf(win_id: int) -> UINT32PTR:
-    return t.CVoid(syscall._syscall2(uint64(syscall.GET_WINBUF), uint64(win_id), 0), t.CPtr)
+    return t.CPtr(syscall._syscall2(uint64(syscall.GET_WINBUF), uint64(win_id), 0))
 
 def get_win_size(win_id: int) -> int:
     return int(syscall._syscall2(uint64(syscall.GET_WIN_SIZE), uint64(win_id), 0))
 
-def flush(win_id: int) -> t.CVoid:
+def flush(win_id: int):
     syscall._syscall2(uint64(syscall.WIN_FLUSH), uint64(win_id), 0)
 
-def mainloop(win_id: int) -> t.CVoid:
+def mainloop(win_id: int):
     syscall._syscall1(uint64(syscall.WAIT_WINDOW), uint64(win_id))
 
 def poll_event(evt: InputEvent | t.CPtr) -> int:
@@ -74,10 +74,10 @@ def poll_event(evt: InputEvent | t.CPtr) -> int:
 def is_active(win_id: int) -> int:
     return int(syscall._syscall2(uint64(syscall.WAIT_WINDOW), uint64(win_id), 1))
 
-def set_cursor_type(win_id: int, cursor_t: int) -> t.CVoid:
+def set_cursor_type(win_id: int, cursor_t: int):
     syscall._syscall2(uint64(syscall.SET_CURSOR), uint64(win_id), uint64(cursor_t))
 
-def set_title(win_id: int, title: t.CConst | t.CChar | t.CPtr) -> int:
+def set_title(win_id: int, title: t.CConst | str) -> int:
     return int(syscall._syscall2(uint64(syscall.SET_TITLE), uint64(win_id), uint64(title)))
 
 def set_geometry(win_id: int, x: int, y: int, w: int, h: int) -> int: