Rust और WebGPU से ब्राउज़र में CAD Kernel बनाना
KetchUp से सीख: Rust और WebGPU ब्राउज़र में असली CAD kernel को व्यावहारिक क्यों बनाते हैं, और पुराने प्रयास किन गलतियों से विफल हुए।

इस हफ़्ते कुछ चुपचाप लेकिन उल्लेखनीय हुआ: ब्राउज़र में CAD kernel अब मज़ाक का विषय नहीं रहा। KetchUp — जिसका नाम अब BenchUp कर दिया गया है, शायद Trimble के ट्रेडमार्क वकीलों को शांत रखने के लिए — Rust में लिखा गया, WebGPU से रेंडर होने वाला, ओपन-सोर्स SketchUp-जैसा modeler है, और यह एक सादे ब्राउज़र टैब में ऐसी रफ़्तार और सफ़ाई से चलता है कि लंबे समय से SketchUp इस्तेमाल करने वाले लोग साफ़ तौर पर जलन महसूस करें। कोई account नहीं। कोई cloud नहीं। .ketchup फ़ाइल सीधे आपकी डिस्क पर डाउनलोड होती है, और पूरा प्रोजेक्ट MIT लाइसेंस के तहत है।
मैंने दो दशकों तक लोगों को "वेब पर CAD" बनाने की कोशिश करते देखा है, और लगभग हर कोशिश एक ही तरह से दम तोड़ गई: गलत runtime, गलत rendering API, और इस बात की गलत समझ कि असली मुश्किल कहाँ है। यह प्रोजेक्ट उन फ़ैसलों में इतने सही निशाने लगाता है कि इसे एक केस स्टडी की तरह देखना सार्थक है। तो यह एक उल्टा postmortem है — वे गलतियाँ जिनसे पुराने browser modelers डूबे, और वे ठोस उपाय जिनसे यह वाला एक नेटिव ऐप जैसा महसूस होता है।
सबक 1: समस्या ब्राउज़र नहीं था — असली अड़चन runtime था
मैं जितने भी असफल वेब CAD प्रोजेक्ट याद कर सकता हूँ, उन सबकी शुरुआत एक जैसी थी: geometry engine JavaScript में लिखा गया, किसी दीवार से टकराए, और नतीजा निकाला कि ब्राउज़र यह काम नहीं कर सकता। नतीजा गलत था। ब्राउज़र ठीक था। दिक़्क़त runtime की थी।
सोचिए interactive modeling असल में क्या माँगती है। आप Push/Pull से किसी face को खींच रहे होते हैं, और माउस के हर मूवमेंट पर प्रभावित faces का दोबारा हिसाब होता है, edge inference चलता है, हर पास के vertex के सामने snap टेस्ट होता है, और vertex buffers फिर से GPU पर भेजे जाते हैं — हर सेकंड साठ बार। JavaScript में frame का बजट garbage collector तय करता है। उसे इससे कोई मतलब नहीं कि आप बीच ड्रैग में हैं। गलत समय पर लगी कुछ मिलीसेकंड की सफ़ाई यूज़र को "lag" जैसी लगती है, और modeling tool में lag कोई छोटी असुविधा नहीं; वह हाथ और आकृति के बीच का मानसिक रिश्ता तोड़ देता है। इसीलिए SketchUp का वेब वर्ज़न उसके अपने यूज़र्स के शब्दों में हमेशा "धीमा और कम क्षमता वाला" लगा, desktop वर्ज़न के मुक़ाबले।
Rust को WebAssembly में compile करने से failure की वह पूरी श्रेणी ही खत्म हो जाती है। आपको अपनी memory पर नियंत्रण मिलता है, geometry buffers का layout पूर्वानुमेय रहता है, और frames के बीच कोई collector छिपा नहीं रहता। अहम बात यह है कि Wasm हर काम में जादुई रूप से तेज़ नहीं है — हम पहले भी WebAssembly के उन मामलों पर लिख चुके हैं जहाँ वह अच्छी तरह ट्यून किए JavaScript से पीछे रह जाता है, खासकर string-भारी और DOM-से जुड़े कामों में। लेकिन geometry kernel इसके ठीक उलट workload है: f32 के बड़े, सपाट arrays पर कसे हुए loops। ठीक यहीं अनुमानित memory जीतती है, और JS का object model सबसे ज़्यादा अड़ंगा डालता है।
तो हल "ब्राउज़र को तेज़ बनाना" नहीं है। हल है — documents के लिए बने runtime पर geometry engine चलाना बंद करना। ब्राउज़र सिर्फ़ डिलीवरी का माध्यम है। उसके भीतर चलने वाली चीज़ system code हो सकती है।
सबक 2: CAD रेंडरिंग के लिए WebGPU बनाम WebGL — समझकर चुनें कि आप क्या खरीद रहे हैं
दूसरी गलती ज़्यादा सूक्ष्म है: यह मान लेना कि WebGL काफ़ी है, क्योंकि "modeler तो बस triangles है।" Shaded triangles बनाना सचमुच सबसे आसान हिस्सा है। असली दर्द उन triangles के आसपास के काम में है, और वहीं WebGL आपको तकलीफ़ देता है।
थोड़ा इतिहास, क्योंकि यह API के डिज़ाइन को समझाता है। WebGL, OpenGL की सीधी संतान है, और OpenGL SGI के IRIS GL की। यह एक state machine है, जो अस्सी के दशक के अंत में ऐसे hardware के लिए बनी थी जो अब मौजूद नहीं। इसमें आप global context state बदलते हैं और हर draw call से पहले सही knobs सेट होने की उम्मीद करते हैं। 1992 के लिए यह एक ठीक abstraction था। CAD viewport के लिए आपको बार-बार वे काम करने पड़ते हैं जो इसमें अटपटे हैं: GPU पर picking (कर्सर के नीचे कौन-सी face है?), छेद वाली faces का tessellation, edges की screen-space line width का हिसाब, और ऐसे buffers का प्रबंधन जो हर frame बदलते हैं। यह सब WebGL2 में किया जा सकता है, लेकिन आप compute-जैसे काम को ऐसे API पर चढ़ा रहे होते हैं जिसमें न compute shaders हैं और न ही हर जगह बिखरी implicit synchronization से छुटकारा।
WebGPU सिर्फ़ speed नहीं, model भी ठीक करता है। छिपे global state की जगह explicit pipelines। Storage buffers और compute shaders, ताकि tessellation और picking उसी GPU पर हों जहाँ डेटा पहले से है। एक error model जो चुपचाप गिरने की जगह बताता है कि आपने क्या गलत किया। और — यही रणनीतिक रूप से अहम हिस्सा है — Rust का wgpu crate वही API Vulkan, Metal और Direct3D पर लागू करता है। अपना renderer एक बार wgpu पर लिखिए, वह ब्राउज़र में WebGPU में compile होगा और desktop पर native graphics में। यही एक फ़ैसला है जिसकी वजह से BenchUp एक ही tree से Windows, macOS, Linux और browser builds भेज पाता है।
ईमानदार चेतावनी: WebGPU का समर्थन सार्वभौमिक नहीं है, और एक गंभीर tool को WebGL2 fallback चाहिए — BenchUp को इनमें से एक चाहिए। लेकिन पहले WebGPU के लिए बनाना और फिर सुंदरता से नीचे उतरना सही क्रम है। उल्टा क्रम वही रास्ता है जिससे आप आर्किटेक्चर के स्तर पर 1992 में फँस जाते हैं।
सबक 3: geometry kernel असली मुश्किल नहीं है — inference है
यह गलती मुझे सबसे दिलचस्प लगती है, क्योंकि यह इंजीनियरिंग की नहीं, प्राथमिकता की विफलता है। जब डेवलपर modeler की नकल करने निकलते हैं, तो लगभग हमेशा geometry kernel से शुरू करते हैं: boundary representations, Euler operators, boolean की मज़बूती। यह सबसे बौद्धिक रूप से गंभीर हिस्सा है, तो पहले यही आना चाहिए। है न?
गलत, और इतिहास बताता है क्यों। Solid modeling kernels दशकों से सुलझी हुई और commodity समस्या हैं — BRL-CAD सत्तर के दशक के अंत में अमेरिकी सेना के लिए constructive solid geometry कर रहा था, Parasolid और ACIS ने अस्सी के दशक में boundary representation को उद्योग में उतारा, और OpenCASCADE 1999 से ओपन सोर्स है। अगर कोई ताक़तवर kernel ही product होता, तो OpenCASCADE पर आधारित कोई न कोई modeler SketchUp की रोज़ी छीन चुका होता। कोई नहीं छीन पाया। क्योंकि SketchUp की प्रतिभा, जब @Last Software ने 2000 में इसे Boulder से निकाला, geometric ताक़त नहीं थी। वह था inference engine: कर्सर का midpoints पर snap होना, लाल-हरी-नीली axes में लॉक होना, और उस plane का अंदाज़ा लगाना जिस पर आप बना रहे हैं। यूज़र कभी coordinates नहीं टाइप करते। सॉफ़्टवेयर हाथ को वहीं मिलता है जहाँ वह है।
SketchUp असल में एक ख़ूबसूरत रूप से सरल surface modeler है — faces और edges, solids की ज़रूरत नहीं। Push/Pull बस एक face को extrude करना और किनारों को जोड़ना है। जटिलता interaction layer में रहती है, और KetchUp ने साफ़ तौर पर अपनी मेहनत वहीं लगाई है। Snap का logic कुछ ऐसा दिखता है:
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)
}
उस function में गणित के हिसाब से कुछ भी गहरा नहीं है। गहराई priority ordering में है, zoom के साथ tolerance के scaling में, और उन तीस सूक्ष्म व्यवहारों में जो इसे झटकेदार की जगह "टेलीपैथिक" महसूस कराते हैं। यह kernel की सैद्धांतिक किताबों के हज़ार पन्नों की नहीं, बल्कि हज़ार घंटे की tuning की बात है। अगर आप modeler बना रहे हैं, तो पहले inference layer बनाइए और geometry को शर्मनाक रूप से सरल रखिए, जब तक यूज़र्स और न माँगें।
Inference engine ही product है। geometry kernel बस plumbing है। Plumbing की नकल सबसे आख़िर में करें।

सबक 4: CAD UI को DOM nodes से मत बनाइए
चौथी गलती React जैसी आदत से आती है। "canvas वाली web app" का डिफ़ॉल्ट architecture एक DOM application होता है जो एक <canvas> element के चारों ओर लिपटा होता है: toolbars div की तरह, panels components की तरह, dialogs portals की तरह। एक CRUD app के लिए यह ठीक है। एक modeling tool के लिए आपने एक layout engine, जो styles को invalidate करता है और अनुमान से बाहर reflow करता है, उस renderer के बगल में चिपका दिया है जिसे अपने frame का हर माइक्रोसेकंड चाहिए। फिर आप debug करते हैं कि toolbar पर hover करने से orbit के दौरान frame क्यों छूट रहा है।
KetchUp उल्टा रास्ता लेता है: पूरा UI GPU पर बनाया जाता है, और DOM घटकर एक ही canvas रह जाता है। यही architectural कदम GPU-accelerated terminal emulators ने उठाया था — Alacritty और उसके साथी DOM से हर cell में text रेंडर करवाना बंद करके window को एक texture की तरह देखने लगे। आधुनिक terminal के glyph-atlas तरीक़े में हमने देखा कि यह कितना अच्छा काम करता है। Rust का इकोसिस्टम इसे लगभग मुफ़्त बना देता है: egui जैसा immediate-mode GUI Wasm में compile होता है, wgpu से रेंडर होता है, और बिना एक भी DOM node के buttons, panels और text देता है। एक Hacker News commenter, जो इसके नेटिव जैसे एहसास से चकित था, ख़ास तौर पर text रेंडरिंग का ज़िक्र करता है। यह संयोग नहीं है — text ही वह जगह है जहाँ DOM-मुक्त UI अक्सर लड़खड़ाते हैं, और उसे सही करना बताता है कि रेंडरिंग स्टैक सचमुच मज़बूत है।
इसका trade-off असली है, तो उसे नाम दीजिए: immediate-mode UI हर frame पर फिर से layout करता है, accessibility tools DOM मानकर चलते हैं, और ब्राउज़र की बनी-बनाई हर सुविधा छूट जाती है। कुछ सौ widgets वाली tool surface के लिए, जो 60fps पर दोबारा बनती है, recomputation की लागत नगण्य है। Accessibility की लागत वह है जो आपको ईमानदार रखनी चाहिए — पर वह कम करने की चीज़ है, reflow के तूफ़ानों को वापस लाने का बहाना नहीं।
सबक 5: Local-first फ़ाइलें cloud lock-in से बेहतर हैं
अब वह गलती जो तकनीकी बिल्कुल नहीं है। 2012 में जब Trimble ने Google से SketchUp ख़रीदा, तो उत्पाद धीरे-धीरे उसी जानी-पहचानी राह पर चल पड़ा: मुफ़्त desktop वर्ज़न (SketchUp Make) बंद कर दिया गया, मुफ़्त tier एक account के पीछे वाली web app बन गया, और perpetual licenses ख़त्म करके सालाना सैकड़ों डॉलर वाली subscriptions लाई गईं। समुदाय की नाराज़गी असल में पैसों की नहीं है — शौक़ीन लोग बार-बार कहते हैं कि वे एक उचित एकमुश्त क़ीमत ख़ुशी से देंगे। नाराज़गी शर्तों की है। लोगों के घरों के मॉडल हैं जिन्हें बनाने में उन्होंने सालों लगाए, और वे एक ऐसे format और licensing ढाँचे में रखे हैं जिसकी क़ीमत उनके नीचे से बढ़ाई जा सकती है। एक commenter आज भी 2017 का मुफ़्त build WINE में चलाता है, नई डील मानने के बजाय। यह पुरानी यादों का मामला नहीं है। यह बंधक बनाए जाने की बातचीत है।
KetchUp का हल लगभग ज़िद्दी ढंग से पुराने ज़माने का है: autosave आपके device पर browser storage में जाता है, File → Save एक पोर्टेबल .ketchup प्रोजेक्ट फ़ाइल डाउनलोड करता है, SketchUp .skp geometry imports स्थानीय रूप से चलते हैं, और बाहर निकलना चाहें तो OBJ export मौजूद है। कोई server नहीं। कोई account नहीं। Documentation सीधी भाषा में चेतावनी भी देता है कि browser data साफ़ करने से आपके autosaves मिट जाएँगे — यही local-first software का ईमानदार समझौता है, पहले से बताया हुआ।
इस हिस्से पर मैं ज़ोर देना चाहता हूँ, क्योंकि यह इस लेख का सबसे पुराना सबक है: फ़ाइल format ही lock-in है, और interoperability ही वह crowbar है। हर सफल चुनौती देने वाला उत्पाद किसी जमे हुए tool की फ़ाइलें पढ़ने से शुरू हुआ। WordPerfect Word की feature सूची से नहीं, बल्कि Word के import filters से हारा। KetchUp की अपनाए जाने में SketchUp import किसी भी एक modeling feature से ज़्यादा मायने रखता है। OBJ export का सिर्फ़ geometry होना (materials नहीं) एक स्वीकार्य खोट है; यह संकेत देता है कि दिशा बाहर की ओर है, अंदर की ओर नहीं।
सबक 6: Rust में लिखें, एक बार — और native व web दोनों पर चलाएँ
आख़िरी गलती है "वेब वर्ज़न" को अलग उत्पाद मानना। ऐतिहासिक रूप से यही होता आया: C++ में एक native codebase, और फिर एक समानांतर web प्रयास, सालों पीछे, और हमेशा कमतर। यूज़र्स महसूस कर लेते थे कि असली उत्पाद कौन-सा है और कौन-सा सिर्फ़ डेमो।
जिस stack पर KetchUp खड़ा है, वह इस फ़र्क़ को मिटा देता है। Rust Wasm को पहले दर्जे का target मानता है। wgpu ब्राउज़र में WebGPU बोलता है और desktop पर Vulkan/Metal/D3D। egui दोनों जगह बिना बदलाव चलता है। Browser build और native builds चचेरे भाई नहीं हैं — वे एक ही प्रोग्राम हैं, जो दो बार compile हुआ है। मैं यह बताए बिना नहीं रह सकता कि यह वह वादा है जो Java ने 1995 में किया था और जो अब पूरा हो रहा है, एक ऐसे bytecode format के ज़रिए जिसमें कोई garbage collector नहीं और कोई भाषा-विचारधारा जुड़ी नहीं। WebAssembly एक compile target के रूप में इसलिए सफल हुआ क्योंकि उसने कभी ऐसा platform बनने की कोशिश नहीं की जिसमें आप लिखें। ब्राउज़र चुपचाप native-स्तर के code के लिए एक भरोसेमंद ठिकाना बन गया है — हमने यह टैब में चलते statically recompiled console games में देखा है, और CAD बस अगली शैली है जो इसके आगे गिरेगी।

एक और सिलवट सोचने लायक है। हर संकेत से यह प्रोजेक्ट काफ़ी हद तक AI coding सहायता से बना लगता है — समुदाय ने यह तुरंत भाँप लिया, और ज़्यादातर प्रतिक्रिया कंधे उचकाने और तारीफ़ की रही। यह उस पैटर्न से मेल खाता है जिसे कई commenters ने खुलकर नाम दिया: हम ऐसे दौर में पहुँच रहे हैं जहाँ अपना tool बनाना किसी और का tool सीखने का एक व्यावहारिक विकल्प है। Rust, wgpu और एक AI साथी के साथ एक प्रेरित व्यक्ति अब उस उत्पाद के मूल loop को दोबारा बना सकता है, जिसे एक सार्वजनिक कंपनी सालाना सैकड़ों डॉलर में किराए पर देती है। यह दौर आपको ख़ुश करता है या डराता है, यह शायद इस पर निर्भर है कि आप invoice के किस तरफ़ बैठे हैं।
KetchUp शायद वह प्रोजेक्ट हो या न हो जो शौक़ीन modelers को स्थायी ठिकाना दे — यह अभी छोटा है, इसका geometry core सरल है, और बड़े मॉडलों वाले SketchUp के कट्टर समर्थक इसकी सीमा जल्दी पा लेंगे। लेकिन एक अस्तित्व-प्रमाण के रूप में यह अपना काम पहले ही कर चुका है। ब्राउज़र CAD के लिए कभी इतना कमज़ोर नहीं था। हम ही उसे गलत तरीक़े से बना रहे थे: गलत runtime, गलत API, गलत प्राथमिकताएँ, गलत business model। ये चार चीज़ें ठीक कर दीजिए, तो $300 सालाना की subscription जड़ता पर लगा कर एक टैक्स जैसी लगने लगती है।


