Kupas Tuntas Bevy 0.20: Era Baru Game Engine Rust, Adopsi WESL, dan Kegilaan ECS yang Bikin Otak Meledak!

Sambat Pembuka: Ketika Wong Edan Nyoba Nulis Game Pake Rust

Heh, para pemuja kepiting besi Rust dan petarung baris kode di seluruh jagat raya! Ketemu lagi sama saya, blogger teknologi paling waras di antara orang-orang yang sudah kehilangan kewarasannya akibat memikirkan lifetime bounds dan borrow checker. Kali ini, otak saya yang sudah setengah matang ini mendadak mendidih lagi. Kenapa? Ya apa lagi kalau bukan karena rilisnya Bevy 0.20! Rilis ini bener-bener gila, cuk! Bayangkan saja, di tengah gempuran engine komersial yang semakin hari semakin rakus memori dan lisensi, komunitas open-source Rust malah makin kesetanan bikin teknologi yang bikin geleng-geleng kepala.

Kalau kalian masih berpikir bahwa menulis game itu harus pakai drag-and-drop visual yang lambat dan bikin laptop kalian berbunyi seperti helikopter tempur, kalian salah besar. Bevy hadir dengan filosofi data-driven murni yang memanfaatkan paradigma Entity Component System (ECS). Tapi sebelum kita masuk ke jeroan kode yang rumit dan njlimet, mari kita sujud syukur dulu kepada 227 kontributor luar biasa yang sudah menyumbangkan 817 pull requests demi mewujudkan rilis ini. Detail kontribusi dan rilis epik ini bisa kalian pelototi langsung di halaman berita rilis Bevy 0.20 resmi. Edan! Bayangkan berapa cangkir kopi hitam tanpa gula yang habis buat ngetik kode sebanyak itu!

Di artikel teknis super panjang ini, saya tidak cuma mau mengulas “fitur baru apa saja yang keren”, ndasmu sempal! Kita bakal bedah sampai ke level memori, arsitektur shader, hingga perubahan paradigma berpikir yang dipicu oleh rilis 0.20 ini. Siapkan kopi, matikan notifikasi WhatsApp dari pacar kalian (kalau punya), dan mari kita melompat ke jurang kegilaan ECS Bevy!

1. Paradoks Filosofis: Bevy Itu Game Engine atau Cuma Library?

Sebelum kita menulis satu baris kode pun di Bevy 0.20, kita harus membereskan satu kesalahpahaman akut yang sering membuat developer pemula menangis di pojokan server Discord. Banyak orang mengira Bevy adalah alternatif langsung untuk Unity atau Unreal Engine yang tinggal klik-klik langsung jadi game RPG kelas AAA. Heh, sadarlah! Ada satu diskusi menarik di jagat Reddit yang menyebutkan bahwa kita harus melihat Bevy dengan kacamata yang berbeda.

“And you need to think of Bevy more as a library, not as a game engine. You’re more on your own.”

— Diskusi Reddit: Di mana Posisi Bevy Sekarang?

Pernyataan di atas itu benar-benar mencerahkan sekaligus menampar wajah kita. Di Bevy 0.20, filosofi “library first” ini semakin terasa kental. Bevy tidak menyediakan editor grafis bawaan (GUI) yang memanjakan mata secara default. Semuanya adalah kode Rust yang murni, eksplisit, dan sangat modular. Bevy adalah kumpulan dari berbagai crate (pustaka) yang digabungkan secara harmonis lewat sistem plugin.

Bagi “Wong Edan” seperti saya, ini adalah surga duniawi! Mengapa? Karena kita tidak dipaksa membawa beban bloatware editor yang berat. Kita punya kendali penuh atas alokasi memori, jalannya thread CPU, dan bagaimana rendering pipeline berinteraksi dengan GPU. Tapi konsekuensinya, ya itu tadi: “You’re more on your own.” Kalau kalian butuh tools UI editor untuk menyusun level, kalian harus membangunnya sendiri atau menggunakan crate buatan komunitas. Bevy memberikan fondasi semen yang sangat kokoh, tapi kalianlah yang harus menata batu bata dan gentengnya sendiri dengan jemari kalian yang kapalan itu.

2. Adopsi WESL (WebGPU Extended Shading Language): Revolusi Shader Modular!

Nah, sekarang kita masuk ke menu utama yang bikin para developer grafis berbusa mulutnya. Salah satu lompatan teknologi paling radikal di Bevy 0.20 adalah adopsi resmi bahasa shader baru! Berdasarkan bocoran diskusi sebelum rilis di diskusi Reddit tentang rilis Bevy 0.20, Bevy secara resmi mengadopsi WESL (WebGPU Extended Shading Language)!

Mengapa ini penting? Mari kita kilas balik sejenak. Sebelumnya, WebGPU menggunakan WGSL (WebGPU Shading Language) sebagai standar shading-nya. WGSL itu sebenarnya bagus, bersih, dan aman. Tapi, dia punya satu kelemahan besar: sangat kaku dan tidak mendukung modularitas tingkat tinggi. Kalian tidak bisa dengan mudah melakukan import fungsi shader dari berkas lain, atau membuat generic shader yang bisa dikustomisasi secara dinamis tanpa teknik string concatenation yang menjijikkan dan rawan bug.

WESL hadir sebagai ekstensi standar dari WGSL untuk menyelesaikan masalah ini. Mari kita lihat bagaimana WESL mendefinisikan ulang cara kita menulis shader di Bevy 0.20. Dengan WESL, kita bisa menulis shader seperti kita menulis modul di Rust!

// Contoh kode shader WESL fiktif yang menggambarkan modularitas baru
import bevy_pbr::pbr_types::{GpuLighting, calculate_light};
@fragment
fn fragment_main(
@location(0) world_position: vec4<f32>,
@location(1) world_normal: vec3<f32>
) -> @location(0) vec4<f32> {
let normal = normalize(world_normal);
let light_color = calculate_light(world_position, normal);
return vec4<f32>(light_color * vec3<f32>(1.0, 0.5, 0.2), 1.0);
}

Di balik layar, Bevy 0.20 menggunakan parser WESL yang akan menerjemahkan (transpile) kode modular di atas menjadi kode WGSL murni yang valid sebelum dikirim ke driver GPU. Proses translasi ini terjadi pada tingkat Abstract Syntax Tree (AST), bukan sekadar manipulasi string murahan! Ini artinya, jika ada kesalahan sintaksis atau tipe data pada shader kalian, kompiler Bevy akan langsung memberikan error yang sangat deskriptif lengkap dengan nomor barisnya saat aplikasi dijalankan (atau bahkan saat compile-time jika menggunakan perkakas tooling yang tepat). Ini adalah peningkatan luar biasa dibanding era sebelumnya, di mana shader yang error hanya akan menghasilkan layar hitam misterius tanpa pesan kesalahan yang jelas.

3. Bedah Jeroan Arsitektur ECS Bevy 0.20: Optimasi Cache Locality

Bagi kalian yang belum tahu, jantung utama dari performa legendaris Bevy adalah sistem ECS-nya. Berbeda dengan Unity kuno yang menggunakan pendekatan berbasis GameObject dan Component (yang sebenarnya adalah struktur pointer yang berantakan di memori heap), Bevy menggunakan pendekatan Archetype-based ECS.

Mari kita bedah secara teknis bagaimana data kalian disimpan di RAM dalam Bevy 0.20. Ketika kalian membuat sebuah entitas dengan beberapa komponen, Bevy tidak akan menyebarkan komponen-komponen tersebut di berbagai alamat memori acak. Sebaliknya, Bevy mengelompokkan entitas yang memiliki tipe komponen yang sama persis ke dalam satu wadah memori kontinu yang disebut Table dan diorganisasi dalam Archetype.

Misalkan kita memiliki tipe entitas berikut:

• Entitas A memiliki komponen: Position dan Velocity
• Entitas B memiliki komponen: Position dan Velocity
• Entitas C memiliki komponen: Position, Velocity, dan Sprite

Di dalam memori, Entitas A dan B akan diletakkan berdampingan secara rapat di dalam satu Archetype (sebut saja Archetype X). Sementara Entitas C akan diletakkan di Archetype Y karena dia memiliki komponen tambahan bernama Sprite. Ketika sistem kalian berjalan untuk memperbarui posisi semua objek bergerak:

fn update_movement(mut query: Query<(&mut Position, &Velocity)>) {
for (mut pos, vel) in query.iter_mut() {
pos.x += vel.x;
pos.y += vel.y;
}
}

Query ini hanya akan memindai Archetype yang memiliki setidaknya komponen Position dan Velocity. Karena data disimpan secara berurutan di dalam memori fisik (kontinu), CPU kalian tidak perlu melakukan pencarian memori yang lambat ke sana kemari. CPU akan memanfaatkan fitur L1/L2 Cache Prefetching dengan sangat optimal. Data ditarik langsung dalam bentuk blok memori besar ke dalam cache CPU yang super cepat. Efisiensinya bisa naik hingga berkali-kali lipat dibandingkan pemrograman berorientasi objek tradisional!

Di Bevy 0.20, algoritma pencarian kecocokan Archetype (Archetype Matching) ini telah dioptimalkan lebih jauh lagi. Struktur data internal yang menyimpan relasi antar Archetype kini menggunakan struktur graf yang lebih efisien, mengurangi overhead saat entitas ditambahi atau dikurangi komponennya secara dinamis di tengah-tengah gameplay loop yang padat.

4. Statistik dan Evolusi Proyek: Membandingkan Bevy 0.19 dan Bevy 0.20

Sebagai blogger yang mengedepankan data empiris, saya tidak mau cuma membual tanpa angka. Mari kita bandingkan rilis Bevy 0.20 ini dengan rilis sebelumnya, yaitu Bevy 0.19. Berdasarkan catatan sejarah di halaman arsip berita Bevy, versi 0.19 dibangun berkat kontribusi dari 261 kontributor dengan total 1185 pull requests.

Sementara itu, Bevy 0.20 hadir dengan 227 kontributor dan 817 pull requests. Lho, kok jumlah kontributor dan PR-nya menurun? Apakah Bevy mulai ditinggalkan developernya? Apakah komunitasnya mulai jenuh dan pindah haluan?

Heh, lambemu! Justru sebaliknya! Penurunan jumlah PR ini merupakan indikasi kuat bahwa arsitektur inti Bevy sudah semakin matang, stabil, dan solid! Di versi-versi awal (seperti 0.5 hingga 0.12), setiap rilis baru selalu diwarnai dengan perombakan total (breaking changes) berskala masif yang mengubah cara kerja ECS secara keseluruhan. Komunitas harus bekerja ekstra keras untuk menulis ulang ribuan baris kode.

Pada rilis Bevy 0.20, fokus komunitas telah bergeser dari “merombak fondasi dasar” menjadi “menghaluskan detail kegunaan, optimasi mikro, dan integrasi ekosistem”. Ini tecermin dari status milestone Bevy 0.20 di GitHub yang berfokus pada penyelesaian bug-bug kritis, peningkatan performa compiler (sehingga compile-time Rust tidak lagi membuat kalian sempat naik haji dulu), dan integrasi mulus dengan WESL. Bevy sekarang bukan lagi proyek eksperimental anak bawang; ia menjelma menjadi platform game development tingkat produksi yang sangat andal!

5. Tutorial Praktis: Setup Proyek Bevy 0.20 Pertamamu

Bicara teori terus tanpa praktik itu namanya omong kosong, alias ndobos! Mari kita buka terminal kalian, bersihkan sisa-sisa air liur di meja kerja, dan mari kita setup proyek Bevy 0.20 pertama kita dari nol.

Pertama, pastikan kalian sudah menginstal kompiler Rust versi terbaru. Jika belum, segera instal menggunakan rustup. Jika sudah, jalankan perintah berikut untuk menginisialisasi proyek kargo baru:

cargo new edan_bevy_game --bin
cd edan_bevy_game

Sekarang, kita perlu menambahkan dependensi Bevy versi terbaru ke berkas Cargo.toml kita. Sesuai dengan rincian di halaman crates.io Bevy, kita akan menambahkan paket resmi Bevy versi 0.20.0:

cargo add bevy@0.20.0

Atau jika kalian adalah tipe petarung baris kode manual yang suka menulis berkas konfigurasi secara langsung, buka berkas Cargo.toml kalian dan tambahkan baris berikut di bawah bagian dependensi:

[dependencies]
bevy = "0.20.0"

Setelah itu, mari kita tulis kode paling legendaris dalam sejarah umat manusia di berkas src/main.rs. Kita akan membuat simulasi sederhana di mana ada sebuah entitas bertipe “Pemain” yang berputar di ruang hampa udara, diiringi dengan pencetakan teks konsol yang tidak kalah gilanya.

use bevy::prelude::*;
// Kita definisikan komponen unik kita menggunakan struct kosong (tag component)
#[derive(Component)]
struct Player;
// Komponen untuk menyimpan kecepatan rotasi
#[derive(Component)]
struct RotationSpeed(f32);
fn main() {
// Memulai inisialisasi aplikasi Bevy
App::new()
// DefaultPlugins akan memuat window manager, renderer (WGPU/WESL), input handler, dll.
.add_plugins(DefaultPlugins)
// Menambahkan sistem startup yang hanya dijalankan satu kali di awal permainan
.add_systems(Startup, setup_scene)
// Menambahkan sistem update yang dieksekusi setiap frame secara paralel
.add_systems(Update, rotate_player_system)
.run();
}
fn setup_scene(mut commands: Commands, asset_server: Res<AssetServer>) {
// Spawn kamera 2D agar kita bisa melihat objek di layar
commands.spawn(Camera2dBundle::default());
// Spawn entitas pemain dengan Sprite, Transform, dan komponen kustom kita
commands.spawn((
SpriteBundle {
texture: asset_server.load("player_sprite.png"), // Pastikan gambar ini ada di folder assets/
transform: Transform::from_xyz(0.0, 0.0, 0.0),
..default()
},
Player,
RotationSpeed(2.0), // Kecepatan rotasi dalam radian per detik
));
println!("Sistem Startup Selesai! Pemain edan telah berhasil di-spawn!");
}
// Sistem ini akan mencari entitas yang memiliki komponen Player, Transform, dan RotationSpeed
fn rotate_player_system(
time: Res<Time>,
mut query: Query<(&mut Transform, &RotationSpeed), With<Player>>,
) {
for (mut transform, speed) in query.iter_mut() {
// Melakukan rotasi pada sumbu Z berdasarkan delta time agar kecepatannya konsisten
transform.rotate_z(speed.0 * time.delta_seconds());
}
}

Mari kita bedah secara mendalam kode di atas dari sudut pandang compiler Rust:

• App::new(): Ini adalah entry point utama Bevy. Dia membangun struktur data kosong yang akan menampung semua konfigurasi sistem, resource, dan plugin kalian.
• DefaultPlugins: Ini adalah kumpulan plugin bawaan wajib yang mencakup segalanya dari pipeline rendering berbasis WESL baru, manajemen window menggunakan winit, hingga sistem input keyboard dan mouse. Jika kalian ingin membuat game tanpa grafis (seperti game server murni), kalian bisa menggantinya dengan plugin minimalis lainnya.
• Query<(&mut Transform, &RotationSpeed), With<Player>>: Di sinilah keajaiban sistem tipe data Rust terjadi. Kompiler akan memeriksa tanda tangan fungsi ini saat compile-time. Bevy menjamin bahwa tidak akan pernah ada konflik mutabilitas data (data race) saat mengeksekusi sistem ini secara paralel dengan sistem lainnya. Dua sistem tidak boleh meminta akses mutabel (&mut) ke komponen yang sama pada entitas yang sama secara bersamaan. Jika ada potensi itu, Bevy akan menjadwalkannya berjalan secara sekuensial secara otomatis! Sungguh pintar dan edan!

6. Tantangan Nyata: Mengapa Bevy Bukan untuk Semua Orang?

Meskipun saya sangat memuja Bevy 0.20 sampai busa mulut saya kering, saya tidak mau bersikap tidak adil kepada kalian. Menulis game di Bevy 0.20 bukanlah perjalanan yang selalu mulus penuh taburan bunga mawar. Ada beberapa tantangan berat yang siap mematahkan semangat kalian di tengah jalan:

1. Kurva Pembelajaran Rust yang Sangat Curam: Jika kalian belum menguasai konsep dasar Rust seperti kepemilikan data (ownership), peminjaman (borrowing), masa pakai (lifetime), dan trait, kalian akan merasa seperti sedang disiksa lahir batin saat mencoba menggunakan Bevy. Kompiler Rust akan menjadi musuh terbesar sekaligus sahabat terbaik kalian.
2. Ketiadaan Editor Visual Resmi: Seperti kutipan Reddit di atas, kalian benar-benar “on your own”. Jika di Unity kalian tinggal menggeser objek di layar untuk menata level, di Bevy kalian harus menulis koordinat angka di dalam kode atau berinvestasi waktu untuk membuat/mengintegrasikan editor pihak ketiga seperti LDTK atau editor komunitas lainnya.
3. Breaking Changes yang Masih Terjadi: Meskipun Bevy 0.20 jauh lebih stabil dari versi-versi sebelumnya, migrasi dari versi lama ke versi baru masih sering membutuhkan penyesuaian kode secara manual karena beberapa API mengalami restrukturisasi demi performa yang lebih optimal.

Kesimpulan: Apakah Bevy 0.20 Layak Dicoba?

Jawaban singkatnya: MUTLAK YA, CUK!

Jika kalian adalah developer yang peduli dengan performa mentah, efisiensi penggunaan memori, keindahan kode yang bersih, serta ingin terlepas dari belenggu lisensi engine komersial yang menjerat leher, Bevy 0.20 adalah pilihan terbaik saat ini. Integrasi bahasa shader WESL yang modular membuktikan bahwa tim pengembang Bevy sangat serius dalam membawa teknologi rendering modern ke dalam ekosistem Rust.

Perjalanan Bevy masih sangat panjang, tetapi fondasi kokoh yang diletakkan pada versi 0.20 ini membuktikan bahwa masa depan pengembangan game open-source berkinerja tinggi ada di tangan Rust. Jadi, tunggu apa lagi? Ambil keyboard mekanikal kesayangan kalian, instal Rust, tambahkan dependensi Bevy 0.20, dan mulailah menulis kode seperti orang gila!

Sampai jumpa di artikel berikutnya, tetaplah waras di tengah gempuran teknologi yang gila ini!