Instalasi #

Rust menggunakan pendekatan instalasi yang berbeda dari kebanyakan bahasa pemrograman. Alih-alih menginstal compiler secara langsung dari repositori OS, ekosistem Rust memusatkan segalanya melalui satu tool bernama rustup — sebuah version manager yang mengurus compiler, toolchain, target kompilasi, dan komponen tambahan sekaligus. Ini berarti kamu bisa berpindah antara versi stabil, beta, dan nightly dalam satu mesin tanpa konflik, dan memperbarui seluruh toolchain hanya dengan satu perintah. Artikel ini memandu kamu melalui proses instalasi di Linux, macOS, dan Windows, sekaligus menjelaskan apa saja yang sebenarnya terinstal dan bagaimana cara mengelolanya secara efektif.

Memahami Komponen Rust #

Sebelum menginstal, penting untuk memahami apa saja yang akan masuk ke sistem kamu. Rust bukan sekadar satu binary — ia adalah ekosistem tool yang saling terhubung.

Berikut gambaran komponen utama yang akan terinstal bersama Rust:

flowchart TD
    rustup["rustup\n(Version Manager)"]
    rustup --> rustc["rustc\n(Compiler Rust)"]
    rustup --> cargo["cargo\n(Build System & Package Manager)"]
    rustup --> std["std\n(Standard Library)"]
    rustup --> rustfmt["rustfmt\n(Code Formatter)"]
    rustup --> clippy["clippy\n(Linter)"]
    rustup --> docs["rust-docs\n(Dokumentasi Offline)"]

    cargo --> build["cargo build"]
    cargo --> test["cargo test"]
    cargo --> run["cargo run"]
    cargo --> publish["cargo publish"]

Komponen	Fungsi	Tersedia di
rustup	Version manager, mengurus seluruh toolchain	Diinstal pertama kali
rustc	Compiler resmi Rust	Bagian dari toolchain
cargo	Build system dan package manager	Bagian dari toolchain
std	Standard library Rust	Bagian dari toolchain
rustfmt	Formatter kode otomatis	Komponen opsional
clippy	Linter dan saran idiomatis	Komponen opsional
rust-docs	Dokumentasi offline	Komponen opsional

rustup sendiri adalah lapisan teratas — ia yang mengatur versi toolchain mana yang aktif, komponen apa yang terinstal, dan target platform apa yang didukung. Semua file toolchain tersimpan di direktori ~/.rustup/, sementara binary yang bisa dieksekusi (seperti rustc dan cargo) tersimpan di ~/.cargo/bin/.

Tiga Varian Toolchain Rust #

Rust menyediakan tiga channel rilis yang masing-masing punya tujuan berbeda. Memahami ini penting sebelum memilih apa yang akan diinstal.

flowchart LR
    nightly["Nightly\nRilis tiap malam\nFitur eksperimental"]
    beta["Beta\nRilis tiap 6 minggu\nKandidat stable berikutnya"]
    stable["Stable\n✓ Direkomendasikan\nRilis tiap 6 minggu\nGaransi backward-compatible"]

    nightly --> beta
    beta --> stable

    style stable fill:#22c55e,color:#fff
    style beta fill:#f59e0b,color:#fff
    style nightly fill:#64748b,color:#fff

stable — toolchain produksi. Semua fitur sudah diuji dan dijamin tidak breaking. Gunakan ini untuk semua proyek nyata.
beta — kandidat untuk stable berikutnya. Digunakan untuk menguji apakah proyek kamu kompatibel dengan rilis stable mendatang.
nightly — rilis setiap malam dari branch main. Berisi fitur yang belum stabil, dibutuhkan untuk beberapa crate tertentu dan untuk pengembangan Rust itu sendiri.

Instalasi default menggunakan stable, yang adalah pilihan yang benar untuk hampir semua kasus.

Instalasi di Linux #

Linux adalah platform paling straightforward untuk instalasi Rust. rustup menyediakan skrip instalasi satu baris yang menangani semua kebutuhan.

Prasyarat #

Sebelum menjalankan skrip instalasi, pastikan curl tersedia di sistem kamu:

# Debian/Ubuntu
sudo apt update && sudo apt install curl -y

# Fedora
sudo dnf install curl -y

# Arch Linux
sudo pacman -S curl

Rust juga membutuhkan C linker untuk menghubungkan binary. Di sebagian besar distribusi ini sudah tersedia, tapi jika tidak:

# Debian/Ubuntu — instal build-essential
sudo apt install build-essential -y

# Fedora
sudo dnf groupinstall "Development Tools" -y

# Arch Linux
sudo pacman -S base-devel

Instalasi via rustup #

Jalankan perintah berikut di terminal:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Flag yang digunakan di sini punya alasan keamanan yang spesifik: --proto '=https' memaksa hanya protokol HTTPS yang boleh digunakan, dan --tlsv1.2 memastikan versi TLS minimum 1.2. Ini melindungi dari serangan downgrade protokol saat mengunduh skrip instalasi.

Setelah dijalankan, skrip akan menampilkan menu pilihan:

Current installation options:

   default host triple: x86_64-unknown-linux-gnu
     default toolchain: stable (default)
               profile: default
  modify PATH variable: yes

1) Proceed with standard installation (default - just press enter)
2) Customize installation
3) Cancel installation

Tekan 1 atau langsung Enter untuk instalasi default. Jika kamu ingin mengkustomisasi (misalnya memilih toolchain nightly atau profile minimal), pilih 2.

Setelah proses selesai, muat ulang konfigurasi shell tanpa perlu restart terminal:

source "$HOME/.cargo/env"

Atau jika menggunakan fish shell:

source "$HOME/.cargo/env.fish"

Verifikasi Instalasi #

# Cek versi compiler
rustc --version
# Output: rustc 1.78.0 (9b00956e5 2024-04-29)

# Cek versi cargo
cargo --version
# Output: cargo 1.78.0 (54d8815d0 2024-03-26)

# Cek versi rustup
rustup --version
# Output: rustup 1.27.0 (2024-03-08)

Instalasi via Package Manager (Tidak Direkomendasikan) #

Beberapa distribusi menyediakan paket Rust di repositori resmi mereka. Namun, versi ini hampir selalu jauh tertinggal dari versi stable terbaru.

# ANTI-PATTERN: menginstal Rust dari repositori distro
# Versi yang tersedia biasanya beberapa bulan tertinggal
sudo apt install rustc  # Debian/Ubuntu — mungkin mendapat Rust 1.63 saat stable sudah 1.78

# BENAR: selalu gunakan rustup untuk mendapat versi terbaru
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Menginstal Rust dari repositori distro membatasi kemampuan kamu untuk memperbarui ke versi stable terbaru, mengelola beberapa toolchain, dan menginstal komponen seperti rustfmt atau clippy. Selalu gunakan rustup kecuali ada alasan infrastruktur yang sangat spesifik.

Instalasi di macOS #

Proses instalasi di macOS identik dengan Linux — menggunakan skrip rustup yang sama. Perbedaannya ada di prasyarat sistem.

Prasyarat: Xcode Command Line Tools #

Rust membutuhkan C linker yang disediakan oleh Apple melalui Xcode Command Line Tools. Jika belum terinstal:

xcode-select --install

Sebuah dialog GUI akan muncul meminta konfirmasi instalasi. Klik “Install” dan tunggu prosesnya selesai (biasanya 5–15 menit tergantung koneksi internet).

Verifikasi bahwa linker tersedia:

cc --version
# Output: Apple clang version 15.0.0 (clang-1500.3.9.4)

Instalasi via rustup #

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Prosesnya identik dengan Linux. Setelah selesai, muat ulang konfigurasi shell:

source "$HOME/.cargo/env"

Untuk pengguna Zsh (default di macOS sejak Catalina), pastikan .cargo/env dimuat di .zshrc:

# Tambahkan ke ~/.zshrc jika belum ada secara otomatis
echo 'source "$HOME/.cargo/env"' >> ~/.zshrc

Instalasi via Homebrew (Alternatif) #

Homebrew juga menyediakan rustup-init sebagai formula:

brew install rustup-init
rustup-init

Metode ini menginstal rustup yang sama, bukan Rust langsung. Hasilnya identik dengan mengunduh skrip secara langsung — ini hanya alternatif bagi kamu yang lebih suka mengelola semua tool lewat Homebrew.

Jika sebelumnya kamu pernah menginstal Rust via brew install rust (bukan rustup-init), hapus dulu dengan brew uninstall rust sebelum menginstal via rustup. Keduanya bisa konflik di PATH.

Verifikasi Instalasi #

rustc --version
cargo --version

# Tes kompilasi sederhana
echo 'fn main() { println!("Rust berjalan di macOS!"); }' > /tmp/test.rs
rustc /tmp/test.rs -o /tmp/test_rust && /tmp/test_rust
# Output: Rust berjalan di macOS!

Instalasi di Windows #

Windows memiliki dua jalur instalasi yang perlu kamu pilih berdasarkan kebutuhan: instalasi native menggunakan MSVC, atau lewat WSL untuk pengalaman yang lebih dekat dengan Linux.

Prasyarat: Microsoft C++ Build Tools #

Rust di Windows native (target x86_64-pc-windows-msvc) membutuhkan linker dari Microsoft Visual C++. Ada dua cara mendapatkannya:

Opsi A: Visual Studio Build Tools (lebih ringan)

Unduh Build Tools for Visual Studio
Saat instalasi, centang “Desktop development with C++”
Pastikan komponen berikut terpilih: MSVC v143, Windows SDK, dan CMake tools

Opsi B: Visual Studio Community (lebih lengkap)

Unduh Visual Studio Community (gratis)
Pilih workload “Desktop development with C++”

Instalasi via rustup-init.exe #

1. Buka browser dan kunjungi https://rustup.rs
2. Klik tombol "DOWNLOAD RUSTUP-INIT.EXE (64-BIT)"
3. Jalankan file rustup-init.exe yang sudah diunduh
4. Di jendela Command Prompt yang muncul, tekan 1 untuk instalasi default
5. Setelah selesai, buka Command Prompt atau PowerShell baru

# Verifikasi di PowerShell atau Command Prompt baru
rustc --version
cargo --version

Kamu harus membuka terminal baru setelah instalasi selesai agar perubahan PATH berlaku. Terminal yang sudah terbuka sebelum instalasi tidak akan mengenali rustc atau cargo.

Instalasi via WSL (Windows Subsystem for Linux) #

Jika kamu sudah menggunakan WSL 2, instalasi Rust di dalam WSL mengikuti langkah-langkah Linux persis sama. Rust yang terinstal di WSL adalah instalasi terpisah dari Rust native Windows.

# Di dalam WSL terminal
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source "$HOME/.cargo/env"
rustc --version

Keputusan antara native Windows vs WSL bergantung pada target proyek kamu:

Aspek	Native Windows (MSVC)	WSL (Linux)
Target binary	`.exe` Windows native	Linux binary
Interoperabilitas	Windows API, COM, DirectX	POSIX, socket Linux
Performa kompilasi	Baik	Sangat baik
Ekosistem crate	Hampir semua kompatibel	Semua kompatibel
Rekomendasi untuk	Aplikasi desktop Windows	Backend, CLI, server

Memahami Struktur Direktori Instalasi #

Setelah instalasi selesai, Rust tersebar di dua direktori utama. Memahami ini membantu saat troubleshooting atau membersihkan instalasi.

~/.rustup/                    ← Direktori rustup
  ├── toolchains/
  │   ├── stable-x86_64-unknown-linux-gnu/
  │   │   ├── bin/            ← Binary (rustc, cargo, dll.)
  │   │   ├── lib/            ← Standard library
  │   │   └── share/          ← Dokumentasi
  │   └── nightly-x86_64-unknown-linux-gnu/  ← Jika diinstal
  ├── tmp/                    ← File sementara unduhan
  └── update-hashes/          ← Hash untuk verifikasi update

~/.cargo/                     ← Direktori cargo
  ├── bin/                    ← Symlink ke binary aktif (ada di PATH)
  │   ├── rustc               ← Symlink → ~/.rustup/toolchains/.../bin/rustc
  │   ├── cargo               ← Symlink → ~/.rustup/toolchains/.../bin/cargo
  │   ├── rustfmt
  │   └── clippy-driver
  ├── registry/               ← Cache crate dari crates.io
  └── git/                    ← Cache dependensi dari git

~/.cargo/bin/ yang ada di PATH hanya berisi symlink, bukan binary asli. Binary asli ada di ~/.rustup/toolchains/. Saat kamu mengganti toolchain aktif dengan rustup default, symlink ini diperbarui secara otomatis.

Mengelola Toolchain #

Salah satu kekuatan terbesar rustup adalah kemampuan mengelola beberapa toolchain sekaligus. Ini penting ketika kamu bekerja di beberapa proyek yang membutuhkan versi Rust berbeda.

Menginstal Toolchain Tambahan #

# Instal toolchain nightly
rustup install nightly

# Instal versi spesifik
rustup install 1.75.0

# Instal toolchain beta
rustup install beta

Melihat Toolchain yang Terinstal #

rustup toolchain list
# Output:
# stable-x86_64-unknown-linux-gnu (default)
# nightly-x86_64-unknown-linux-gnu
# 1.75.0-x86_64-unknown-linux-gnu

Mengganti Toolchain Default Global #

# Ganti default ke nightly
rustup default nightly

# Kembali ke stable
rustup default stable

Menentukan Toolchain per Proyek #

Cara yang lebih baik daripada mengganti default global adalah menentukan toolchain di level proyek menggunakan file rust-toolchain.toml:

# rust-toolchain.toml — letakkan di root proyek
[toolchain]
channel = "1.75.0"
components = ["rustfmt", "clippy"]
targets = ["wasm32-unknown-unknown"]

Ketika file ini ada, rustup akan otomatis menggunakan versi yang ditentukan saat kamu menjalankan cargo build, rustc, atau perintah apapun di dalam direktori proyek. Ini memastikan seluruh tim menggunakan versi Rust yang sama.

# Jalankan perintah dengan toolchain yang berbeda dari default
rustup run nightly cargo build

# Atau gunakan syntax +channel
cargo +nightly build
cargo +1.75.0 test

Mengelola Komponen #

Komponen adalah bagian opsional dari toolchain yang bisa diinstal atau dihapus sesuai kebutuhan.

# Lihat semua komponen yang tersedia dan statusnya
rustup component list

# Output (sebagian):
# cargo-x86_64-unknown-linux-gnu (installed)
# clippy-x86_64-unknown-linux-gnu (installed)
# rust-docs-x86_64-unknown-linux-gnu (installed)
# rust-src (available)  ← belum terinstal
# rust-analyzer (available)
# rustfmt-x86_64-unknown-linux-gnu (installed)

# Instal komponen tambahan
rustup component add rust-src      # Source code standard library (dibutuhkan IDE)
rustup component add rust-analyzer # Language server untuk IDE
rustup component add rustfmt       # Formatter
rustup component add clippy        # Linter

# Hapus komponen yang tidak dibutuhkan
rustup component remove rust-docs

Komponen rust-src dan rust-analyzer sangat direkomendasikan jika kamu menggunakan VS Code dengan ekstensi rust-analyzer, karena keduanya memungkinkan fitur seperti go-to-definition ke kode standard library.

Memperbarui Rust #

Memperbarui seluruh toolchain Rust hanya butuh satu perintah:

rustup update

Perintah ini memperbarui semua toolchain yang terinstal (stable, beta, nightly, dan versi spesifik) sekaligus. Output-nya menunjukkan versi sebelum dan sesudah untuk setiap toolchain:

info: syncing channel updates for 'stable-x86_64-unknown-linux-gnu'
info: latest update on 2024-05-02, rust version 1.78.0 (9b00956e5 2024-04-29)
info: downloading component 'rustc'
info: downloading component 'cargo'
  stable-x86_64-unknown-linux-gnu updated - rustc 1.78.0 (9b00956e5 2024-04-29)
  (from rustc 1.77.2 (25ef9e3d8 2024-04-09))

Untuk memperbarui hanya toolchain tertentu:

rustup update stable
rustup update nightly

Dan untuk memperbarui rustup itu sendiri:

rustup self update

Verifikasi Lingkungan dengan Proyek Pertama #

Cara terbaik untuk memverifikasi bahwa seluruh toolchain bekerja dengan benar adalah membuat dan menjalankan proyek Rust pertama menggunakan Cargo:

# Buat proyek baru
cargo new hello-rust
cd hello-rust

Struktur yang dibuat:

hello-rust/
  ├── Cargo.toml    ← Metadata proyek dan dependensi
  └── src/
      └── main.rs   ← Entry point aplikasi

Isi src/main.rs yang digenerate:

fn main() {
    println!("Hello, world!");
}

Jalankan proyek:

# Build dan jalankan sekaligus
cargo run

# Output:
#    Compiling hello-rust v0.1.0 (/home/user/hello-rust)
#     Finished dev [unoptimized + debuginfo] target(s) in 0.54s
#      Running `target/debug/hello-rust`
# Hello, world!

Jika output ini muncul, instalasi berhasil sepenuhnya. Cargo berhasil mengompilasi kode Rust dan menjalankan binary hasilnya.

Menghapus Instalasi Rust #

Jika kamu perlu menghapus Rust sepenuhnya dari sistem:

rustup self uninstall

Perintah ini menghapus semua toolchain, komponen, rustup itu sendiri, dan seluruh direktori ~/.rustup/. Direktori ~/.cargo/ beserta cache registry-nya perlu dihapus secara manual jika kamu ingin membersihkan sepenuhnya:

rm -rf ~/.cargo

Menghapus ~/.cargo/ juga menghapus semua binary yang pernah kamu instal via cargo install (seperti cargo-watch, bacon, just, dan tool lainnya). Pastikan kamu tidak butuh binary-binary tersebut sebelum menghapus direktori ini.

Ringkasan #

Selalu instal via rustup — bukan dari repositori distro atau package manager OS, karena versi yang tersedia di sana hampir selalu tertinggal.
Tiga komponen utama yang terinstal bersama Rust: rustc (compiler), cargo (build system & package manager), dan rustup (version manager).
Gunakan toolchain stable untuk semua proyek produksi. Toolchain nightly hanya dibutuhkan untuk fitur eksperimental tertentu.
rust-toolchain.toml adalah cara yang tepat untuk menentukan versi Rust per proyek, memastikan konsistensi di seluruh tim.
rustup update memperbarui semua toolchain sekaligus — jalankan secara berkala untuk mendapat perbaikan keamanan dan fitur terbaru.
Komponen rust-analyzer dan rustfmt sangat direkomendasikan dari awal — keduanya meningkatkan produktivitas pengembangan secara signifikan.
Verifikasi instalasi dengan menjalankan cargo new dan cargo run, bukan hanya rustc --version — ini memastikan seluruh pipeline build bekerja dengan benar.
Binary ada di ~/.cargo/bin/ yang harus masuk ke PATH; semua toolchain aktual tersimpan di ~/.rustup/toolchains/.

← Sebelumnya: Pengenalan Berikutnya: Sintaks Utama →