Foundation

BAB 2: Build dan Run Program Rust

Dua cara membangun program Rust: rustc langsung dan cargo, lengkap dengan ukuran biner, waktu build, serta perbedaan mode debug dan release.

Program hello world bisa dibangun dengan 1 perintah rustc, tetapi proyek yang memakai pustaka pihak lain tidak bisa lagi dikompilasi begitu saja. Di titik itu cargo mengambil alih: ia mengurus daftar dependensi, urutan kompilasi, dan penamaan berkas hasil.

Bab ini membandingkan kedua cara dengan angka hasil pengukuran di mesin yang sama, memakai rustc 1.100.0 dan cargo 1.100.0. Semua perintah dijalankan, dan setiap angka di bawah diambil dari keluaran sebenarnya.

Kompilasi langsung dengan rustc

Nama berkas hasil kompilasi mengikuti nama berkas sumber tanpa ekstensi. Berkas hello.rs menghasilkan biner hello di direktori yang sama.

CodeTEXT
rustc hello.rs
./hello

Untuk mengaktifkan optimasi, tambahkan -O:

CodeTEXT
rustc -O hello.rs -o hello_opt

2 biner yang dihasilkan dari berkas yang sama punya ukuran berbeda tipis: 4.493.168 byte tanpa optimasi dan 4.492.368 byte dengan -O. Untuk program sekecil hello world, optimasi tidak banyak mengurangi ukuran, karena sebagian besar isi biner adalah kode pustaka standar yang ikut disalin.

rustc cocok untuk berkas tunggal dan untuk memahami cara kerja kompilasi. Begitu program terdiri dari beberapa berkas dan butuh pustaka luar, perintah rustc menjadi panjang dan mudah salah.

Membuat proyek dengan cargo

cargo new membuat struktur proyek yang siap dipakai:

CodeTEXT
cargo new proyek_hello

Isi yang dihasilkan:

CodeTEXT
proyek_hello/Cargo.toml
proyek_hello/src/main.rs
proyek_hello/.gitignore
proyek_hello/.git/

Cargo.toml menyimpan identitas proyek dan daftar dependensi:

CodeTOML
[package]
name = "proyek_hello"
version = "0.1.0"
edition = "2024"

[dependencies]

Bagian [dependencies] masih kosong karena proyek ini belum memakai pustaka luar. Bagian edition menunjukkan versi edisi Rust yang dipakai, dan nilai 2024 berarti aturan bahasa tahun 2024.

Perintah cargo new juga membuat repositori git di dalam folder proyek, kecuali jika dijalankan di dalam repositori yang sudah ada. Folder target sejak awal dimasukkan ke .gitignore, karena isinya berkas hasil kompilasi yang bisa dibuat ulang.

cargo build: mode debug

CodeTEXT
cargo build

Perintah ini menghasilkan biner di target/debug/proyek_hello dengan ukuran 4.501.144 byte, dan pada mesin uji selesai dalam 0,161 detik. Build kedua untuk kode yang sama hanya 0,015 detik, karena cargo menyimpan hasil kompilasi sebelumnya dan tidak mengulang pekerjaan yang tidak berubah.

PerintahHasilWaktu pada mesin uji
cargo buildtarget/debug/proyek_hello0,161 detik
cargo build ulang tanpa perubahantidak mengompilasi ulang0,015 detik
cargo checktidak menghasilkan biner0,036 detik
cargo build --releasetarget/release/proyek_hello0,078 detik

Mode release

CodeTEXT
cargo build --release

Biner release untuk program yang sama berukuran 445.040 byte, jauh lebih kecil daripada versi debug 4.501.144 byte. Perbedaannya lebih dari soal ukuran: kode debug menyimpan informasi tambahan untuk pelacakan kesalahan, sementara kode release dioptimasi dan informasi itu dibuang.

Perbedaan lain yang lebih penting saat program berjalan: pada mode debug, kesalahan aritmetika seperti penambahan yang melewati batas tipe akan menghentikan program dengan panic. Pada mode release, nilainya berputar tanpa pesan. Karena itu program yang diuji di mode debug bisa berperilaku berbeda di mode release.

cargo run dan cargo check

cargo run menjalankan cargo build lalu menjalankan binernya:

CodeTEXT
cargo run
   Compiling proyek_hello v0.1.0 (/tmp/rust/proyek_hello)
    Finished `dev` profile [unoptimized + debuginfo] target(s)
     Running `target/debug/proyek_hello`
Hello, Rust!

cargo run juga menerima --release, dan perintah itu membangun versi release lalu menjalankannya:

CodeTEXT
cargo run --release

Selisih waktunya terasa pada proyek besar, karena versi release dioptimasi dan proses kompilasinya lebih lama, tetapi program yang dihasilkan berjalan lebih cepat.

cargo check memeriksa kode tanpa menghasilkan biner. Waktunya lebih singkat, dan itulah perintah yang dipakai saat sedang menulis kode: salah ketik dan kesalahan tipe langsung ketahuan tanpa menunggu proses penautan selesai.

CodeTEXT
cargo check
    Checking proyek_hello v0.1.0 (/tmp/rust/proyek_hello)
    Finished `dev` profile [unoptimized + debuginfo] target(s)

Perintah dijalankan dari folder yang salah

cargo mencari Cargo.toml di folder tempat ia dijalankan, lalu naik ke folder induk. Kalau tidak menemukannya, keluarannya:

CodeTEXT
error: could not find `Cargo.toml` in `/tmp` or any parent directory

Pesan ini bukan tanda cargo rusak, melainkan tanda perintah dijalankan di luar folder proyek. Pindah ke folder yang memuat Cargo.toml, lalu ulangi perintahnya.

Folder target dan cargo clean

Semua hasil kompilasi masuk ke folder target. Setelah cargo build untuk proyek hello world, ukuran folder itu 4,5 MB. Setelah cargo build --release dijalankan juga, ukurannya menjadi 5,0 MB karena 2 profil disimpan berdampingan.

CodeTEXT
cargo clean

Perintah itu menghapus seluruh folder target. Pada proyek kecil, menghapusnya tidak merugikan apa pun selain waktu kompilasi ulang. Pada proyek besar, folder itu bisa mencapai ratusan MB, dan itulah alasan target selalu masuk .gitignore: isinya dapat dibuat ulang dari kode sumber.

Mengubah profil build

Profil build diatur di Cargo.toml. Pengaturan yang paling sering dipakai adalah tingkat optimasi dan informasi debug pada profil release:

CodeTOML
[profile.release]
opt-level = 3
debug = false
lto = true

[profile.dev]
opt-level = 0
debug = true

Nilai opt-level = 3 berarti optimasi penuh, sedangkan debug = true menyimpan informasi baris untuk pelacakan. lto = true mengaktifkan optimasi antar modul, yang biasanya memperkecil biner tetapi menambah waktu kompilasi.

Perubahan pada bagian ini tidak mengubah kode program. Yang berubah adalah hasil kompilasi dan waktu yang dibutuhkan untuk menghasilkannya.

Build setelah kode diubah

Mengubah 1 baris di src/main.rs membuat cargo build berikutnya mengompilasi ulang crate itu, dan pada mesin uji waktunya 0,101 detik. Angka itu lebih besar daripada build tanpa perubahan yang hanya 0,015 detik, karena ada pekerjaan kompilasi yang dilakukan.

Pada proyek dengan banyak dependensi, pola waktunya berbeda: dependensi yang tidak berubah tidak dikompilasi ulang, sehingga build pertama setelah menambah dependensi jauh lebih lama daripada build berikutnya. Karena itu jangan menyimpulkan cargo lambat dari build pertama saja.

Memeriksa versi alat

Sebelum melaporkan masalah atau mengikuti tutorial, pastikan versi alat yang dipakai diketahui. Kedua perintah ini mencetaknya:

CodeTEXT
rustc -V
rustc 1.100.0 (0ef1bc386 2026-11-09)

cargo -V
cargo 1.100.0 (3acc79c0c 2026-11-05)

Versi yang berbeda bisa memberi pesan kesalahan yang berbeda, dan sebagian fitur baru hanya tersedia pada versi tertentu. Menyebutkan versi saat bertanya membuat jawaban yang diterima lebih tepat.

Kapan memakai yang mana

KebutuhanPerintah
mencoba 1 berkas tanpa proyekrustc berkas.rs
proyek dengan banyak berkascargo build
memeriksa kode saat menuliscargo check
menjalankan sambil membanguncargo run
menyiapkan biner untuk dipakaicargo build --release

Aturan sederhananya: rustc untuk percobaan cepat, cargo untuk semua yang akan disimpan.

Ringkasan

rustc mengompilasi 1 berkas menjadi 1 biner, dengan nama mengikuti berkas sumber, dan flag -O mengaktifkan optimasi. cargo new membuat struktur proyek berisi Cargo.toml dan src/main.rs, lalu cargo build menghasilkan biner di target/debug.

Mode release menghasilkan biner jauh lebih kecil, 445.040 byte dibandingkan 4.501.144 byte pada program yang sama, dan mengubah perilaku kesalahan aritmetika dari panic menjadi perputaran nilai. cargo check memeriksa kode tanpa menghasilkan biner, dan cargo run menggabungkan build dengan menjalankan hasilnya.

Referensi

  1. The Rust Programming Language. Hello, Cargo!.
  2. The Cargo Book. cargo build.
  3. The Cargo Book. cargo run.
  4. The Cargo Book. cargo check.
  5. The rustc book. What is rustc?.