Artikel mendalam tentang teknologi yang membentuk masa depan.

Membangun Kernel CAD di Browser dengan Rust dan WebGPU

Pelajaran dari KetchUp: cara Rust dan WebGPU membuat kernel CAD di browser akhirnya layak, serta kesalahan yang menggagalkan upaya sebelumnya.

Meja kerja kayu yang setengah berupa kayu fisik dan setengah berupa mesh wireframe bercahaya, terbelah secara diagonal.
BenchUp menyasar pengrajin kayu terlebih dahulu, yaitu orang yang ingin memodelkan rak sebelum memotong kayunya.

Ada sesuatu yang diam-diam luar biasa terjadi minggu ini: kernel CAD di browser sudah tidak lagi jadi bahan lelucon. KetchUp, yang kini berganti nama menjadi BenchUp, mungkin supaya tim hukum Trimble tetap sibuk dengan urusan lain, adalah modeler open-source bergaya SketchUp yang ditulis dengan Rust, dirender dengan WebGPU, dan berjalan di tab browser biasa dengan kecepatan dan kerapian yang membuat pengguna SketchUp yang sudah lama menderita ikut iri. Tanpa akun. Tanpa cloud. File .ketchup langsung terunduh ke disk, dan seluruh proyeknya berlisensi MIT.

Saya sudah dua dekade melihat orang mencoba “CAD di web”, dan hampir semua percobaan itu gagal dengan cara yang sama: runtime yang salah, API rendering yang salah, atau gagasan yang salah tentang bagian tersulitnya. Proyek ini membuat cukup banyak keputusan yang tepat sehingga layak dijadikan studi kasus. Jadi inilah postmortem terbalik: kesalahan yang menenggelamkan modeler browser sebelumnya, dan perbaikan spesifik yang membuat yang satu ini terasa seperti aplikasi native.

Pelajaran 1: Browser Bukan Hambatan Utamanya, Runtime-lah

Hampir setiap proyek CAD web yang gagal yang bisa saya ingat membuat langkah awal yang sama: mereka menulis mesin geometri dengan JavaScript, menabrak tembok, lalu menyimpulkan bahwa browser memang tidak sanggup. Kesimpulannya keliru. Browser-nya baik-baik saja. Runtime-lah masalahnya.

Pikirkan apa yang sebenarnya dibutuhkan pemodelan interaktif. Anda sedang menarik sebuah permukaan dengan Push/Pull, dan setiap gerakan mouse memicu penghitungan ulang permukaan yang terdampak, inferensi tepi, pengujian snap terhadap setiap vertex terdekat, dan unggah ulang vertex buffer, enam puluh kali per detik. Di JavaScript, garbage collector yang menguasai anggaran frame Anda. Ia tidak peduli bahwa Anda sedang di tengah drag. Beberapa milidetik pengumpulan sampah di waktu yang salah terasa bagi pengguna sebagai lag, dan lag di alat pemodelan bukan sekadar gangguan; ia memutus loop mental antara tangan dan bentuk. Itulah sebabnya versi web SketchUp selalu terasa, menurut kata penggunanya sendiri, “lebih lambat dan kurang mumpuni” dibanding versi desktop.

Rust yang dikompilasi ke WebAssembly menghilangkan seluruh kelas kegagalan itu. Anda mendapat linear memory yang bisa Anda kendalikan, tata letak yang deterministik untuk buffer geometri, dan tidak ada collector yang mengintai di antara frame. Yang penting, Wasm tidak secara ajaib lebih cepat untuk segala hal. Kami pernah membahas bahwa WebAssembly sering kalah dari JavaScript yang disetel dengan baik pada pekerjaan yang berat string dan dekat-DOM. Tapi kernel geometri justru beban kerja sebaliknya: loop ketat di atas array datar besar berisi f32. Di sanalah memori yang dapat diprediksi menang, dan di sanalah model objek JS paling sering melawan Anda.

Jadi perbaikannya bukan “membuat browser lebih cepat”. Melainkan “berhenti menjalankan mesin geometri di runtime yang dirancang untuk dokumen”. Browser hanyalah mekanisme distribusinya. Yang berjalan di dalamnya boleh berupa kode systems.

Pelajaran 2: WebGPU vs WebGL untuk Rendering CAD, Pahami Apa yang Anda Beli

Kesalahan kedua lebih halus: menganggap WebGL sudah cukup karena “modeler itu cuma segitiga”. Merender segitiga berbayang memang bagian yang paling mudah. Yang merepotkan adalah semua hal di sekitar segitiga itu, dan di sanalah WebGL menyakitkan.

Sedikit sejarah, karena ini menjelaskan API-nya. WebGL adalah turunan langsung dari OpenGL, yang juga turunan langsung dari IRIS GL milik SGI, sebuah state machine yang dirancang akhir 1980-an untuk perangkat keras yang sudah tidak ada. Anda memprogramnya dengan mengubah state konteks global dan berharap sudah mengatur tombol yang benar sebelum setiap draw call. Itu abstraksi yang masuk akal untuk tahun 1992. Untuk viewport CAD, Anda terus-menerus butuh hal-hal yang canggung di sana: picking di sisi GPU (sisi mana yang ada di bawah kursor?), tessellation permukaan berlubang, menghitung lebar garis tepi dalam ruang layar, dan mengelola buffer yang berubah setiap frame. Semua itu bisa dilakukan di WebGL2, tetapi Anda harus memasang pekerjaan berbentuk compute pada API yang tidak punya compute shader dan sinkronisasi implisit di mana-mana.

WebGPU memperbaiki modelnya, bukan sekadar kecepatannya. Pipeline eksplisit menggantikan state global tersembunyi. Storage buffer dan compute shader memungkinkan tessellation dan picking berjalan di GPU, tempat datanya sudah berada. Model error-nya memberi tahu Anda apa yang salah, alih-alih diam-diam gagal. Dan ini bagian yang penting secara strategis: crate Rust wgpu mengimplementasikan API yang sama di atas Vulkan, Metal, dan Direct3D. Tulis renderer Anda sekali dengan wgpu dan ia terkompilasi ke WebGPU di browser serta ke grafis native di desktop. Keputusan tunggal inilah yang membuat BenchUp bisa merilis build Windows, macOS, Linux, dan browser dari satu repositori.

Catatan jujurnya: dukungan WebGPU belum universal, sehingga alat yang serius perlu jalur fallback WebGL2. BenchUp membutuhkan salah satunya. Tapi membangun untuk WebGPU lebih dulu lalu menurunkan kualitas secara elegan adalah urutan yang tepat. Urutan terbalik adalah cara Anda terjebak secara arsitektural di tahun 1992.

Pelajaran 3: Kernel Geometri Bukan Bagian Tersulit, Inferensi Iya

Kesalahan yang paling menarik bagi saya adalah kesalahan prioritas, bukan rekayasa. Ketika developer mulai mengkloning modeler, mereka hampir selalu mulai dari kernel geometri: boundary representation, operator Euler, ketahanan operasi boolean. Itu bagian yang paling serius secara intelektual, jadi harus didahulukan. Benar begitu?

Salah, dan sejarah menunjukkan alasannya. Kernel pemodelan solid sudah menjadi masalah yang terselesaikan dan berstatus komoditas sejak puluhan tahun lalu. BRL-CAD sudah melakukan constructive solid geometry untuk US Army di akhir 1970-an, Parasolid dan ACIS mengindustrialisasi boundary representation di 1980-an, dan OpenCASCADE bersifat open source sejak 1999. Jika kernel yang kuat adalah produknya, salah satu dari banyak modeler berbasis OpenCASCADE pasti sudah menggerus SketchUp bertahun-tahun lalu. Tidak ada yang berhasil. Karena kejeniusan SketchUp, ketika @Last Software merilisnya dari Boulder pada 2000, bukanlah kekuatan geometrinya. Melainkan mesin inferensi-nya: cara kursor menempel ke titik tengah, mengunci ke sumbu merah-hijau-biru, dan menebak bidang tempat Anda menggambar. Pengguna tidak pernah mengetik koordinat. Perangkat lunaknya menemui tangan di tempat tangan itu berada.

Pada dasarnya SketchUp adalah surface modeler yang sederhana dan elegan, dengan permukaan dan tepi, tanpa perlu solid. Push/Pull hanyalah mengekstrusi sebuah permukaan dan menjahit sisinya. Kompleksitasnya ada di lapisan interaksi, dan di situlah KetchUp jelas mencurahkan usahanya. Logika snap-nya kurang lebih seperti ini:

enum Inference {
AtVertex(VertexId),
Midpoint(EdgeId),
OnEdge(EdgeId),
OnAxis(Axis),   // the famous red / green / blue lock
OnFace(FaceId),
None,
}
fn infer(ray: Ray, model: &Model, last_point: Vec3, tol: f32) -> (Vec3, Inference) {
// Priority order matters more than cleverness:
// hard snaps beat soft snaps, every time.
if let Some(v) = model.nearest_vertex(ray, tol) {
return (v.pos, Inference::AtVertex(v.id));
}
if let Some((e, t)) = model.nearest_midpoint(ray, tol) {
return (e.point_at(t), Inference::Midpoint(e.id));
}
if let Some(p) = snap_to_axis(ray, last_point, tol) {
return (p, Inference::OnAxis(p.axis));
}
// Fall through to whatever face or plane the ray hits.
project_onto_surface(ray, model)
}

Tidak ada yang secara matematis dalam di fungsi itu. Kedalamannya ada pada urutan prioritas, toleransi yang menyesuaikan zoom, dan lusinan perilaku kecil yang membuatnya terasa seperti membaca pikiran, alih-alih patah-patah. Itu seribu jam penyetelan, bukan seribu halaman teori kernel. Jika Anda membangun modeler, bangun lapisan inferensi lebih dulu dan biarkan geometrinya sangat sederhana sampai pengguna menuntut lebih.

Mesin inferensi adalah produknya. Kernel geometri hanyalah pipa di belakang layar. Kloning pipanya belakangan.

Kubus transparan bercahaya sedang diekstrusi, dengan garis panduan sumbu merah, hijau, biru, dan sebuah titik snap.
Kunci sumbu dan snap titik tengah terasa sepele sampai Anda mencoba membuatnya terasa tanpa usaha.

Pelajaran 4: Jangan Membangun UI CAD dari Node DOM

Kesalahan keempat adalah yang berbentuk React. Arsitektur default untuk “aplikasi web dengan canvas” adalah aplikasi DOM yang membungkus elemen <canvas>: toolbar sebagai div, panel sebagai komponen, dialog sebagai portal. Untuk aplikasi CRUD itu baik-baik saja. Untuk alat pemodelan, Anda baru saja menempelkan layout engine yang membatalkan style dan melakukan reflow secara tak terduga ke sisi renderer yang membutuhkan setiap mikrodetik dari frame-nya. Lalu Anda harus mencari tahu mengapa state hover pada toolbar menyebabkan frame drop saat orbit.

KetchUp mengambil jalan sebaliknya: seluruh UI digambar di GPU, dan DOM direduksi menjadi satu canvas. Ini langkah arsitektur yang sama dengan yang diambil emulator terminal yang dipercepat GPU. Alacritty dan kawan-kawan berhenti meminta DOM merender teks sel demi sel dan mulai memperlakukan jendela sebagai tekstur. Kita sudah melihat seberapa baik hasilnya dalam pendekatan glyph-atlas pada terminal modern. Ekosistem Rust membuatnya hampir gratis: GUI immediate-mode seperti egui dikompilasi ke Wasm, dirender lewat wgpu, dan memberi Anda tombol, panel, dan teks tanpa satu pun node DOM. Seorang komentator Hacker News, terkejut betapa native rasanya, secara khusus menyebut rendering teksnya. Itu bukan kebetulan. Teks adalah tempat UI tanpa DOM biasanya goyah, dan bisa menanganinya dengan baik adalah tanda bahwa tumpukan rendering-nya benar-benar solid.

Trade-off-nya nyata, jadi sebutkan: UI immediate-mode menghitung ulang layout setiap frame, tooling aksesibilitas mengasumsikan DOM, dan Anda melepaskan semua fitur bawaan browser. Untuk permukaan alat dengan beberapa ratus widget yang digambar ulang 60fps, biaya perhitungan ulang itu tidak berarti. Biaya aksesibilitas adalah yang seharusnya membuat Anda tetap jujur, tapi itu biaya yang harus dimitigasi, bukan alasan untuk mengembalikan badai reflow.

Pelajaran 5: File Local-First Mengalahkan Lock-In Cloud

Sekarang kesalahan yang sama sekali tidak teknis. Ketika Trimble mengakuisisi SketchUp dari Google pada 2012, produk ini perlahan menempuh jalan yang familiar: versi desktop gratis (SketchUp Make) dihentikan, tier gratis berubah menjadi aplikasi web di balik akun, dan lisensi perpetual dihapus demi langganan yang berharga ratusan per tahun. Kekesalan di komunitas sebenarnya bukan soal uang. Para hobiis berulang kali mengatakan mereka dengan senang hati membayar harga satu kali yang wajar. Ini soal syaratnya. Orang punya model rumah yang menghabiskan bertahun-tahun untuk dibangun, tersimpan dalam format dan rezim lisensi yang bisa dinaikkan harganya begitu saja. Ada seorang komentator yang masih menjalankan build gratis 2017 di bawah WINE daripada menerima kesepakatan baru. Itu bukan nostalgia. Itu negosiasi sandera.

Perbaikan KetchUp sangat kuno dengan cara yang hampir menantang: autosave disimpan di penyimpanan browser di perangkat Anda, File → Save mengunduh file proyek .ketchup yang portabel, impor geometri .skp dari SketchUp berjalan secara lokal, dan ekspor OBJ tersedia saat Anda ingin keluar. Tidak ada server. Tidak ada akun. Dokumentasinya bahkan memperingatkan dengan bahasa sederhana bahwa menghapus data browser akan menghapus autosave Anda, dan itu adalah trade-off jujur dari perangkat lunak local-first yang dinyatakan di awal.

Inilah bagian yang ingin saya tekankan, karena ini pelajaran tertua dalam tulisan ini: format file adalah lock-in, dan interoperabilitas adalah linggis. Setiap penantang sukses terhadap alat yang sudah mapan dimulai dengan membaca file milik incumbent. WordPerfect kalah bukan karena daftar fiturnya, melainkan karena filter impor Word. Impor SketchUp lebih menentukan adopsi KetchUp dibanding fitur pemodelan tunggal mana pun. Ekspor OBJ yang hanya berisi geometri (tanpa material) adalah cacat yang bisa diterima; itu menandakan arahnya keluar, bukan ke dalam.

Pelajaran 6: Tulis Sekali dengan Rust, Jalankan Secara Native dan di Web

Kesalahan terakhir adalah memperlakukan “versi web” sebagai produk terpisah. Secara historis begitulah jalannya: basis kode native dalam C++, lalu upaya web paralel, bertahun-tahun di belakang, selamanya lebih rendah. Pengguna bisa merasakan mana yang produk asli dan mana yang demo.

Tumpukan yang menopang KetchUp membuat perbedaan itu hilang. Rust memperlakukan Wasm sebagai target kelas satu. wgpu berbicara WebGPU di browser dan Vulkan/Metal/D3D di desktop. egui berjalan di kedua tempat tanpa perubahan. Build browser dan build native bukan saudara sepupu; mereka adalah program yang sama, dikompilasi dua kali. Saya tidak bisa menahan diri untuk menunjukkan bahwa ini adalah janji yang dibuat Java pada 1995 yang akhirnya ditepati, oleh format bytecode tanpa garbage collector dan tanpa ideologi bahasa yang melekat. WebAssembly berhasil sebagai target kompilasi justru karena tidak pernah berusaha menjadi platform tempat Anda menulis. Browser diam-diam telah menjadi tujuan yang kredibel untuk kode berkelas native. Kita sudah melihatnya dengan game konsol yang dikompilasi ulang secara statis dan berjalan di tab, dan CAD hanyalah genre berikutnya yang tumbang.

Satu model 3D wireframe terhubung dengan benang cahaya ke tiga siluet perangkat berbeda.
Satu basis kode Rust, dikompilasi ke Wasm dan ke biner native, adalah program yang sama di mana pun.

Ada satu hal lagi yang layak direnungkan. Dari tampilannya, proyek ini sebagian besar dibangun dengan bantuan asisten coding AI. Komunitas langsung menyadarinya, dan responsnya kebanyakan angkat bahu dan pujian. Itu sesuai dengan pola yang beberapa komentator sebutkan secara gamblang: kita memasuki era di mana membangun alat sendiri menjadi alternatif yang realistis dibanding mempelajari alat orang lain. Seorang individu yang termotivasi, bersenjatakan Rust, wgpu, dan pasangan AI, kini bisa mereproduksi inti dari produk yang disewakan perusahaan publik seharga ratusan per tahun. Apakah era itu menyenangkan atau mengkhawatirkan bagi Anda mungkin bergantung pada sisi mana dari faktur itu Anda berada.

KetchUp mungkin atau mungkin tidak menjadi proyek yang akhirnya memberi para modeler hobiis rumah permanen. Ia masih muda, inti geometrinya sederhana, dan para penggemar berat SketchUp dengan model raksasa akan segera menemukan batasnya. Tapi sebagai bukti keberadaan, ia sudah menjalankan tugasnya. Browser tidak pernah terlalu lemah untuk CAD. Kita hanya membangunnya dengan cara yang keliru: runtime yang salah, API yang salah, prioritas yang salah, model bisnis yang salah. Perbaiki keempat hal itu, dan langganan 300 dolar per tahun mulai terlihat seperti pajak atas inersia.