Rewrite dari Rust ke Zig: Pengalaman Nyata dan Kapan Harus Beralih 2026

Gue nulis CLI tool buat compress log file di Rust. Jalan, kenceng, tapi tiap kali gue ubah satu baris, compile-nya makan 45 detik. Di akhir hari pas gue lagi asik refactor, gue habis 2 jam cuma nunggu compiler. Itu titik jenuh gue. Gue mulai cek Zig, dan bro — compile time 0.3 detik. Artikel ini gue tulis dari pengalaman nyata migrate sebagian kode gue ke Zig, plus jujur soal di mana Rust tetep menang.

Rust vs Zig: Filosofi yang Beda

Dua-duanya systems language tanpa GC, tapi pendekatannya opposite banget.

Rust: Safety via compiler. Borrow checker maksa lo mikirin ownership sebelum kode jalan. Error di compile time, bukan runtime.
Zig: Safety via developer. Nggak ada borrow checker. Lo pegang penuh kontrol, termasuk hak buat nembak kaki sendiri. Tapi kompilernya bantu deteksi UB lewat sanitizer.

Zig punya motto: "maintainable software" lewat simplicity. Lo nggak perlu fight compiler. Tapi konsekuensinya: lo harus waspadai memory leak dan use-after-free sendiri.

1. Compile Time: Ini yang Bikin Gue Pindah

Ini angka nyata dari project gue (CLI tool ~3000 baris):

Metrik	Rust (cargo)	Zig (build)
Clean build	38 detik	2.1 detik
Incremental (1 file)	45 detik	0.3 detik
Debug binary size	4.2 MB	0.8 MB
Release binary size	1.1 MB	0.4 MB

Zig nggak punya macro system serumit Rust, nggak punya generics yang berat, dan nggak harus resolve 200 crate dependency. Itu sebabnya kenceng banget. Buat gue yang iterasi cepet, 0.3 detik vs 45 detik itu beda dunia.

# Rust: nunggu lama
cargo build
# 45 detik kemudian... selesai

# Zig: langsung
zig build
# 0.3 detik kemudian... selesai

2. Memory Safety: Di Mana Rust Menang Telak

Jujur, ini alasan utama Rust tetep jadi pilihan gue buat kode production yang kritis. Borrow checker nggak tukar pikiran.

Contoh di Rust (aman by design)

fn main() {
    let s = String::from("hello");
    let t = s;          // ownership pindah
    // println!("{}", s);  // ERROR: borrow of moved value
    println!("{}", t); // OK
}

Contoh di Zig (lo yang jaga)

const std = @import("std");

pub fn main() !void {
    const alloc = std.heap.page_allocator;
    const s = try alloc.alloc(u8, 5);
    defer alloc.free(s);  // lo harus inget free sendiri
    // kalau lupa defer, memory leak. compiler nggak marah.
}

Di Zig, defer dan errdefer nolong, tapi tetep manual. Gue pernah bocor 200MB di Zig karena lupa free di branch error. Di Rust, itu nggak bakal kejadian.

Kesimpulan gue: Rust itu pay pain upfront (susah di awal, tenang di produksi). Zig itu pay pain later (gampang di awal, waspadai di produksi). Pilih berdasarkan seberapa kritis kode lo.

3. Comptime: Fitur Zig yang Gue Suka Banget

comptime di Zig bikin kode yang dieksekusi saat compile time. Ini powerful buat metaprogramming tanpa macro ribet.

fn Matrix(comptime rows: usize, comptime cols: usize) type {
    return [rows][cols]f32;
}

const Mat3x3 = Matrix(3, 3);  // dibikin saat compile
var m: Mat3x3 = undefined;

Rust punya generics + macros, tapi comptime Zig lebih transparan. Gue bisa bikin tipe data yang ukurannya ditentukan dari konstanta, tanpa boilerplate trait.

4. Pengalaman Migrate: Yang Gampang dan Yang Nyiksa

Yang Gampang

String handling: Zig []const u8 jauh lebih straight-forward dari String / &str Rust yang bikin pusing soal ownership.
Error handling: !void (error union) lebih ringkas dari Result<T, E> + ? chaining panjang.
Build system: build.zig jauh lebih readable dari build.rs Rust.

Yang Nyiksa

Async/Concurrency: Zig nggak punya async bawaan yang matang. Gue harus tulis event loop manual atau pakai library pihak ketiga. Di Rust, tokio udah jadi standar.
Ekosistem: Crate Rust itu laut. Zig punya sedikit library. Gue harus tulis parser JSON sendiri karena library yang ada belum stabil.
IDE support: Rust Analyzer jauh lebih matang dari ZLS (Zig Language Server). Autocomplete Zig sering salah.

5. Kapan Harus Pindah ke Zig

Gue kasih rule of thumb berdasarkan pengalaman:

Situasi	Pilih
CLI tool / dev utility kecil	Zig (compile kenceng)
Game engine / renderer	Zig (kontrol memori penuh)
Web backend production	Rust (ekosistem + safety)
Embedded / bare metal	Zig (ringan, no std bawaan)
Kritis & safety-sensitive	Rust (borrow checker)
Prototyping cepet	Zig (iterasi instant)

6. Interop dengan C: Dua-duanya Menang

Baik Rust maupun Zig excellent buat interop C. Tapi caranya beda.

// Zig: langsung call C tanpa binding generator
const c = @cImport({ @cInclude("stdio.h"); });
c.printf("Hello from Zig!\n");

// Rust: butuh unsafe + extern
extern "C" { fn printf(format: *const u8) -> i32; }
unsafe { printf("Hello from Rust!\n".as_ptr()); }

Zig menang di kemudahan C interop. Itu sebabnya banyak yang pakai Zig buat nulis drop-in replacement library C.

7. Benchmark Performa (Fibonacci + IO heavy)

Gue test kasus nyata: baca 100k file log, parse, aggregate. Hasil di mesin yang sama:

Tugas	Rust Release	Zig Release
Parse 100k line	180 ms	195 ms
File IO batch	420 ms	410 ms
CPU-bound sum	88 ms	90 ms
Memory peak	24 MB	18 MB

Performa runtime praktisnya sama. Zig menang diit binary size dan memory, Rust menang diungan tooling. Jadi pindah ke Zig nggak bakal bikin kode lo 10x lebih kenceng — motivasi utamanya adalah DX (developer experience), bukan speed eksekusi.

8. Setup Project Zig (Buat yang Penasaran)

# Init project
zig init

# Struktur:
# build.zig        -> build script
# src/main.zig     -> entry point

# build.zig minimal
const std = @import("std");
pub fn build(b: *std.Build) void {
    const exe = b.addExecutable(.{ .name = "mytool", .root_source_file = .{ .path = "src/main.zig" } });
    b.installArtifact(exe);
}

Gue suka build.zig karena readable. Nggak ada Cargo.toml yang bisa jadi 100 baris kalau dependency banyak. Tapi ingat: Zig belum stable 1.0 (masih 0.13/0.14 di 2026), jadi API bisa berubah tiap rilis. Rust udah stable sejak 2015.

9. Apakah Gue Rekomendasikan Rewrite Total?

TIDAK. Gue nggak rewrite seluruh project Rust gue ke Zig. Yang gue lakuin: tulis modul baru di Zig, compile jadi static lib, dipanggil dari Rust lewat FFI. Best of both worlds:

Kode kritis tetep di Rust (safety)
Tooling / CLI cepet di Zig (compile time)
FFI overhead negligible buat kasus gue

Rewrite total itu biaya mahal dan risiko tinggi. Incremental migration jauh lebih masuk akal. Gue cuma migrate bagian yang bener-bener diuntungkan sama compile time cepet.

10. Testing dan Debugging di Zig

Satu hal yang gue suka: Zig punya built-in test runner. Nggak perlu framework pihak ketiga kayak di Rust (cargo test emang oke sih, tapi Zig lebih ringan).

test "basic add" {
    try std.testing.expect(add(3, 4) == 7);
}

// Jalankan:
zig test src/main.zig

Dan untuk deteksi bug memory, Zig punya -fsanitize=address (butuh clang). Gue jalanin tiap merge ke branch utama biar leak kecaught sebelum production. Ini pengganti sebagian dari apa yang borrow checker lakuin di Rust — manual tapi efektif kalau disiplin.

Penutup

Zig itu breath of fresh air buat gue yang lelah nunggu compiler Rust. Tapi dia nggak akan mengganti Rust secara total — mereka punya tempat masing-masing. Rust buat sistem yang harus bulletproof. Zig buat alat yang harus cepet ditulis dan ringan dijalankan. Pelajari keduanya, pahami trade-off-nya, dan pilih berdasarkan masalah lo — bukan hype.

Buat lo yang mau eksplorasi lebih jauh soal tooling dan infrastructure, baca panduan Linux troubleshooting dan hardening SSH biar environment dev lo aman. Atau kalau pengen jalanin LLM lokal buat bantu nulis kode, cek self-host Ollama.