भविष्य को आकार देने वाली तकनीक पर गहन लेख।

स्टैटिक रीकंपाइलेशन: कंसोल गेम ब्राउज़र में कैसे चलते हैं

स्टैटिक रीकंपाइलेशन पुराने कंसोल और PC बाइनरी को पोर्टेबल कोड में बदलता है। जानिए WebAssembly और WebGPU से पूरे गेम ब्राउज़र टैब में कैसे चलते हैं।

गेम डिस्क को एक मैकेनिकल पाइपलाइन से गुज़रकर लैपटॉप स्क्रीन में रोशनी बनकर बहते हुए दिखाने वाला चित्रण
स्टैटिक रीकंपाइलेशन एक तय बाइनरी को पोर्टेबल सोर्स में बदल देता है — गेम बच जाता है, प्लेटफ़ॉर्म मायने नहीं रखता।

दशक में गेम प्रिज़र्वेशन के लिए सबसे अच्छी चीज़ कोई बेहतर एमुलेटर नहीं है। यह एक कंपाइलर है। जब 2004 की एक पूरी रेसिंग गेम — ऑनलाइन फ़्री रोम, कंट्रोलर सपोर्ट, और 120 fps वाइडस्क्रीन रेंडरिंग के साथ — ब्राउज़र टैब में चलती दिखती है, तो स्वाभाविक लगता है कि किसी ने बहुत चतुर एमुलेटर बनाया होगा। पर ऐसा नहीं है। उन्होंने कुछ ज़्यादा अजीब किया, और मेरे हिसाब से कहीं ज़्यादा अहम: मूल गेम के मशीन कोड को एक तरह के डिकंपाइलर से उल्टा चलाकर C में बदला, और फिर उसे WebAssembly मॉड्यूल के रूप में दोबारा बनाया। इसी को स्टैटिक रीकंपाइलेशन कहते हैं, और यह चुपचाप पुराने सॉफ़्टवेयर को कहीं भी चलाने का सबसे व्यावहारिक तरीका बनता जा रहा है।

एमुलेशन बनाम रीकंपाइलेशन: दो अलग रास्ते

एमुलेटर इस सवाल का जवाब देते हैं कि "इस बाइनरी को कैसे चलाएँ?" वे वह मशीन दोबारा बनाते हैं जिसकी बाइनरी को उम्मीद थी। आपका होस्ट CPU एक-एक इंस्ट्रक्शन और एक-एक साइकिल करके MIPS या PowerPC चिप होने का नाटक करता है। यह काम करता है — MAME, Dolphin और PCSX2 कमाल हैं — पर इसकी कीमत हमेशा चुकानी पड़ती है। हर फ़्रेम में आप ऐसे हार्डवेयर के लिए इंस्ट्रक्शन ट्रांसलेट करते हैं जो पंद्रह साल पहले बंद हो चुका है, और मूल सिलिकॉन की टाइमिंग की खामियाँ ऐसे बग बन जाती हैं जिन्हें आपको बड़ी मेहनत से दोबारा पैदा करना पड़ता है।

स्टैटिक रीकंपाइलेशन उल्टा दांव लगाता है। रनटाइम पर बाइनरी को इंटरप्रेट करने के बजाय, आप उसे एक बार, ऑफ़लाइन, विश्लेषित करते हैं और किसी पोर्टेबल भाषा में उठा लेते हैं — आम तौर पर C में। आउटपुट पुराने हार्डवेयर का सिम्युलेटर नहीं होता। यह एक नया प्रोग्राम होता है जो वही चीज़ें गणना करता है। इसे clang से कंपाइल करते हैं, जिस भी टारगेट के लिए चाहें, और नतीजा नेटिव स्पीड पर चलता है। जब टारगेट wasm32 होता है, तो नतीजा Chrome में चलता है।

इसकी वंशावली जानने लायक है। N64: Recompiled और XenonRecomp जैसे प्रोजेक्ट्स ने कंसोल टाइटल्स पर यह पैटर्न साबित किया, और NFSU2Recomp ने वही विचार Need for Speed: Underground 2 के x86 PC बिल्ड पर लगाया — ओरिजिनल एग्ज़ीक्यूटेबल को C में ट्रांसलेट किया, जिसे फिर फ़ोर्क करके WebGPU, Web Audio और आधुनिक इनपुट APIs से जोड़ा गया। आख़िरी कदम वह हिस्सा है जिस पर वेब डेवलपर्स को ध्यान देना चाहिए, क्योंकि यह हमारे रोज़ के काम से सबसे ज़्यादा मिलता है: एसेट पाइपलाइन, रेंडरिंग बैकएंड और नेटवर्किंग लेयर।

x86 से C में ट्रांसलेशन उतना आसान क्यों नहीं जितना लगता है

कंसोल ROM को लिफ़्ट करना PC एग्ज़ीक्यूटेबल की तुलना में लगभग सभ्य काम है। N64 बाइनरी एक फ़्लैट इमेज होती है जो तय मेमोरी मैप के साथ बेयर मेटल पर चलती है। 2004 का PC गेम एक PE फ़ाइल होता है, जिसे ऑप्टिमाइज़िंग कंपाइलर ने बनाया है, जो vtables के ज़रिए इनडायरेक्ट कॉल करता है, इम्पोर्ट टेबल्स से छलांग लगाता है, और कोड व डेटा को ऐसे मिलाता है कि स्टैटिक एनालिसिस सचमुच मुश्किल हो जाता है।

असली समस्या यह है कि मशीन कोड अपनी सारी टाइप जानकारी खो चुका होता है। रीकंपाइलर call eax देखता है और उसे पता लगाना होता है कि eax आख़िर किस चीज़ की ओर इशारा कर सकता है — किस रजिस्टर में कौन से फ़ंक्शन पॉइंटर आते हैं, किन टेबल्स से, और कहाँ भरे जाते हैं। अगर गलत हुआ तो या तो कोड पाथ छूट जाते हैं (गेम तीसरी रेस पर क्रैश होता है), या डेटा को कोड समझ लिया जाता है (डिसअसेंबलर नीचे की हर चीज़ बिगाड़ देता है)। इसीलिए ये प्रोजेक्ट IDA या Ghidra जैसे टूल्स में इंटरैक्टिव एनालिसिस, मैन्युअल एनोटेशन और बहुत सारी प्लेटेस्टिंग पर निर्भर रहते हैं।

आउटपुट सुंदर C नहीं होता। यह कुछ ऐसा दिखता है:

// Simplified flavor of recompiler output
void sub_4A12C0(CPUState *cpu) {
uint32_t eax = cpu->reg[0];
uint32_t ecx = cpu->reg[1];
eax = mem_read32(cpu, ecx + 0x14);
if (eax != 0) {
cpu->reg[0] = ((FnPtr)mem_read32(cpu, eax + 0x08))(cpu);
}
cpu->reg[0] = eax;
}

रजिस्टर स्ट्रक्ट फ़ील्ड बन जाते हैं, मेमोरी एक बड़ा बाइट ऐरे बन जाती है, और कंट्रोल फ़्लो फ़ंक्शन को फ़ंक्शन कॉल करते हुए बन जाता है। इसे कोई हाथ से नहीं लिखता, और इसे हाथ से मेंटेन करने की ज़रूरत भी किसी को नहीं पड़ती — यह एक मध्यवर्ती आर्टिफ़ैक्ट है। असली बात यह है कि यह कंपाइल होने योग्य है, और एक टारगेट के लिए कंपाइल हो गया तो बाकी सबके लिए भी हो जाता है। यही इसका फ़ायदा है।

WebAssembly तो आसान हिस्सा है

यहाँ एक विरोधी बात है, जो कमाई गई है: रीकंपाइल्ड C को .wasm मॉड्यूल में बनाना पूरे प्रोजेक्ट का सबसे कम दिलचस्प इंजीनियरिंग काम है। Emscripten और clang का wasm टारगेट सालों से भरोसेमंद हैं। अगर आपका कोड पोर्टेबल C है, जिसमें इनलाइन असेंबली नहीं और 32-बिट से आगे पॉइंटर साइज़ की कोई पक्की मान्यता नहीं, तो वह ज़्यादातर बस कंपाइल हो जाता है। हमने पहले उन मामलों के बारे में लिखा है जहाँ WebAssembly JavaScript से तेज़ नहीं होता, लेकिन यह काम wasm के अपने क्षेत्र का है: टाइट न्यूमेरिक लूप, एक बड़ी लीनियर मेमोरी, और DOM की कोई बकबक नहीं। JIT-गर्म JavaScript इसके आसपास भी नहीं पहुँच सकता।

असली काम वह सब है जिसे गेम बाहर कॉल करता है। ओरिजिनल बाइनरी सोचती है कि उसके पास Direct3D 9, DirectInput और Windows ऑडियो स्टैक है। ब्राउज़र में इनमें से कुछ भी नहीं होता। इसलिए पोर्ट को एक shim लेयर बनानी पड़ती है: गेम का हर ग्राफ़िक्स कॉल पकड़ा जाता है और उसे ब्राउज़र की समझ वाले आधुनिक API में दोबारा लिखा जाता है। यहीं WebGPU अपना महत्व साबित करता है — यह पहला वेब ग्राफ़िक्स API है जिसका एब्स्ट्रैक्शन इतना निचले स्तर का है कि 2000 के शुरुआती दौर की फ़िक्स्ड-फ़ंक्शन-जैसी पाइपलाइन को ओवरहेड में डूबे बिना उस पर मैप किया जा सके। रिपोर्ट किया गया नतीजा — वाइडस्क्रीन में 120 fps तक, फ़्री रोम और ऑनलाइन रेस के साथ — वह है जो WebGL आराम से नहीं दे पाता।

प्रैक्टिशनर्स के लिए एक चेतावनी: WebGPU सपोर्ट अभी भी असमान है। Linux पर Chromium उपयोगकर्ताओं को अक्सर --enable-unsafe-webgpu --use-angle=vulkan जैसे फ़्लैग्स के साथ लॉन्च करना पड़ता है ताकि काम करने वाला adapter मिले। "ब्राउज़र में चलता है" का फ़िलहाल मतलब है "सही OS और सही GPU ड्राइवर पर Chrome और Firefox में बढ़िया चलता है।" यह एक असली डिस्ट्रीब्यूशन समस्या है, पर अभी यह सार्वभौमिक नहीं है।

उलझे सर्किट को साफ़ समानांतर धाराओं में सुलझाते हुए तीन परतों वाला अमूर्त चित्रण
पोर्ट का असली काम shim लेयर में होता है: पुरानी Direct3D कॉल अंदर आती हैं, आधुनिक WebGPU कमांड बाहर जाते हैं।

दो गीगाबाइट को एक टैब में स्ट्रीम करना

कोड कुछ मेगाबाइट का होता है। गेम का बाकी 95% एसेट होता है, और यहीं ब्राउज़र पोर्ट सबसे परिचित अर्थ में एक वेब इंजीनियरिंग समस्या बन जाता है। 2000 के मध्य का एक ओपन-वर्ल्ड रेसर गीगाबाइट्स की ज्यामिति, टेक्सचर, ऑडियो और FMV के साथ आता है। इसे कोई लैंडिंग पेज पर डाउनलोड नहीं करेगा। तो वह बनाइए जो हर गेम-स्ट्रीमिंग और बड़ी साइट टीम पहले से जानती है: एक लेज़ी, रेंज्ड और कैश्ड एसेट पाइपलाइन।

इसका ढांचा आम तौर पर ऐसा होता है: मूल एसेट आर्काइव्स को chunked बंडल्स में दोबारा पैक किया जाता है, एक इंडेक्स "इंजन ने अभी जो एसेट माँगा" को "किसी बंडल में बाइट रेंज" से मैप करता है, और वर्चुअल फ़ाइलसिस्टम लेयर HTTP range requests से फ़ेच करती है, और Cache Storage API या IndexedDB में आक्रामक तरीके से कैश करती है ताकि दूसरी विज़िट तुरंत हो। इंजन सोचता है कि वह DVD से पढ़ रहा है; असल में वह एक service worker से पढ़ रहा है। अगर आपने कभी स्ट्रीमिंग geodata पाइपलाइन पर काम किया है, तो आर्किटेक्चर वही जानवर है — कंटेंट-एड्रेस्ड चंक्स, एक इंडेक्स, और एक क्लाइंट जो नेटवर्क को डिस्क होने का नाटक करता है।

  • एक बार दोबारा पैक करें, हमेशा फ़ेच करें: मूल आर्काइव्स को तय आकार के चंक्स में बदलें ताकि HTTP range requests और CDN कैशिंग भारी काम संभालें।
  • अनुमान से पहले से लोड करें: गैराज, पहला ज़िला और मेन्यू का म्यूज़िक पहले मिनट में चाहिए; एयरपोर्ट वाला ज़िला इंतज़ार कर सकता है।
  • बेरहमी से ट्रांसकोड करें: 2004 के दौर का बिना कम्प्रेशन वाला ऑडियो और वीडियो Opus और आधुनिक कोडेक में बदल जाता है। खिलाड़ी फ़र्क नहीं देखता; बैंडविड्थ का बिल ज़रूर फ़र्क देखता है।
  • दिल से कैश करें: लौटने वाले खिलाड़ी का नेटवर्क खर्च लगभग शून्य होना चाहिए। अपरिवर्तनीय, कंटेंट-हैश वाले बंडल इसे आसान बना देते हैं।

वह मल्टीप्लेयर जो मूल गेम में कभी था ही नहीं

ब्राउज़र पोर्ट का सबसे प्रभावशाली हिस्सा यह नहीं है कि गेम चलता है — बल्कि यह है कि अजनबी फ़्री रोम में एक-दूसरे के आसपास बर्नआउट कर रहे हैं। Underground 2 की ऑनलाइन सेवाएँ सालों पहले बंद हो चुकी हैं। यह पोर्ट मरे हुए गेम्स के लिए सिर्फ़ उसी तरीके से मल्टीप्लेयर वापस लाता है जो सचमुच काम करता है: मृत सेवा को बदलो, गेम को नहीं। रीकंपाइल्ड कोड अब भी अपनी मूल नेटवर्किंग कॉल करता है; shim लेयर उन्हें एक आधुनिक बैकएंड की ओर मोड़ देती है, और अचानक 2004 के गेम में क्रू, साझा फ़्री-रोम सेशन और दोस्त को जॉइन करने वाले लिंक आ जाते हैं।

यह पैटर्न नॉस्टेल्जिया से कहीं आगे तक जाता है। किसी भी सॉफ़्टवेयर में जिसकी नेटवर्क निर्भरता मर चुकी है — पुराने गेम, बंद SaaS क्लाइंट, छोड़े गए मल्टीप्लेयर टूल — वह उसी सर्जरी का उम्मीदवार है: क्लाइंट को रीकंपाइल करें या रैप करें, और प्रोटोकॉल को अपने नियंत्रण वाले सर्वर के विरुद्ध दोबारा लागू करें। Hacker News थ्रेड में SimCity 2000 की एक कल्पना थी जिसमें हर पड़ोसी शहर एक असली खिलाड़ी चलाता है। यह कोई सपना नहीं है; ठीक इसी आर्किटेक्चर के ऊपर यह एक वीकेंड प्रोजेक्ट है। साझा दुनिया में कुछ गाड़ियों की स्टेट सिंक ऐसा रास्ता है जिस पर बहुत चला जा चुका है — इतने पैमाने पर WebRTC data channels या एक छोटा authoritative WebSocket सर्वर दोनों काम कर देते हैं।

एमुलेटर मशीन को सुरक्षित रखता है। रीकंपाइलेशन सॉफ़्टवेयर को सुरक्षित रखता है — और लोग असल में वही सॉफ़्टवेयर याद करते हैं।

जहाँ विरोधी दावा टूटता है

मैंने कहा था कि प्रिज़र्वेशन के लिए रीकंपाइलेशन एमुलेशन से बेहतर है, और मैं इस पर विश्वास करता हूँ — पर लागत के बारे में ईमानदार रहें। एमुलेटर सामान्यीकरण करता है: एक Dolphin हज़ारों GameCube गेम चलाता है। रीकंपाइलेशन हस्तनिर्मित कला जैसा है। हर टाइटल का अपना रिवर्स-इंजीनियरिंग अभियान होता है, एक बाइनरी के लिए महीनों का विश्लेषण, और नतीजा केवल उस एक गेम को चलाता है। अगर आपका लक्ष्य पूरी लाइब्रेरी को आर्काइव करना है, तो थ्रूपुट में एमुलेटर जीतते हैं, और यह मुकाबला करीबी भी नहीं है।

एक और बड़ा मुद्दा भी है: कानूनी स्थिति। रीकंपाइल्ड कोड अधिकार-क्षेत्र के हिसाब से ग्रे से लेकर शत्रुतापूर्ण तक किसी भी जगह हो सकता है, और मूल गेम के एसेट्स — गाड़ियाँ, नक्शा, वह Snoop Dogg वाला ट्रैक — होस्ट करना बिल्कुल भी ग्रे नहीं है। Underground 2 व्यावहारिक अर्थ में abandonware है (इसे कहीं खरीदा नहीं जा सकता; म्यूज़िक लाइसेंसिंग शायद इसे ऐसा ही रखती है), लेकिन abandonware एक लोक-अवधारणा है, कानूनी नहीं। टेकडाउन की भविष्यवाणी करने वाली टिप्पणियाँ शायद सही हैं, और प्रोजेक्ट खुद "rights holders" का संपर्क पता तैयार रखता है, जो बताता है कि लेखक भी यह जानता है। तकनीक ठोस और वैध है जब आपके पास बाइनरी या अधिकार हों; यह खास उदाहरण उधार के समय पर चल रहा है।

एक और ईमानदार सीमा: रीकंपाइलेशन तब चमकता है जब लक्ष्य हार्डवेयर स्रोत से बिल्कुल अलग हो — ठीक तब जब एमुलेशन सबसे महंगा होता है। टाइमिंग-संवेदनशील व्यवहार के सटीक पुनरुत्पादन के लिए (स्पीडरन-वैध सटीकता, हार्डवेयर बग्स जो फ़ीचर हों), साइकिल-सटीक एमुलेशन ही एकमात्र सही उत्तर बना रहता है। ये दोनों तरीके प्रतिद्वंद्वी से ज़्यादा अलग-अलग सवालों के जवाब हैं: "हर जगह अच्छी तरह चलाओ" बनाम "बिल्कुल वैसा ही चलाओ।"

वेब डेवलपर्स को इससे क्या लेना चाहिए

नॉस्टेल्जिया हटा दें तो एक ऐसा स्टैक बचता है जो परिचित लगना चाहिए: wasm एक पोर्टेबल कंपाइल टारगेट के रूप में, WebGPU एक असली रेंडरिंग बैकएंड के रूप में, HTTP range requests और Cache Storage एक फ़ाइलसिस्टम के रूप में, WebSocket/WebRTC एक पुनर्जीवित नेटवर्क सेवा के रूप में। इनमें से कुछ भी विदेशी नहीं है। टीमें पहले से ही इसी तरह Python शिप कर रही हैं — हमने बताया था कि Pyodide ब्राउज़र में असली CPython कैसे चलाता है, उसी Emscripten टूलचेन के ज़रिए। रेसिंग गेम उसी थीसिस का कठिन डेमो है: ब्राउज़र गंभीर नेटिव कोड का डिप्लॉयमेंट टारगेट है, कोई दस्तावेज़ व्यूअर जिसे भ्रम हो कि वह कुछ और है, वह नहीं।

Underground 2 को 120 fps पर फ़्री रोम में दोस्तों के साथ चलाने वाला ब्राउज़र टैब वह कर रहा है जो venture-funded गेम-स्ट्रीमिंग इन्फ़्रास्ट्रक्चर के बस की बात नहीं थी: ज़ीरो इंस्टॉल, तुरंत URL से शेयर, और फ़ोन पर भी चलता है। असली कहानी यही है। नेटिव सॉफ़्टवेयर को वेब सॉफ़्टवेयर के रूप में पुनर्जीवित करने का टूलचेन अब मौजूद है, ज़्यादातर ओपन सोर्स है, और कठिन हिस्से — डिकंपाइलेशन, shim लेयर, एसेट स्ट्रीमिंग — रिसर्च की नहीं, इंजीनियरिंग की समस्याएँ हैं। आने वाले समय में इसके और उदाहरण दिखेंगे, टेकडाउन नोटिस समेत।