HN पर: DOOM चलाने वाला अपना खुद का OS kernel बनाना

 (github.com/UnmappedStack)
1 पॉइंट द्वारा GN⁺ 2025-04-26 | 1 टिप्पणियां | WhatsApp पर शेयर करें
  • TacOS C और assembly में शुरू से लिखा गया, अपने kernel पर आधारित UNIX-like hobby OS है, जो DOOM और कई छोटे user-space programs चला सकता है
  • kernel में VFS, scheduler, TempFS, devices, context switching, virtual memory management, physical page frame allocation, और Doom port शामिल हैं
  • execution environment real hardware और Qemu emulator, दोनों को support करता है, और real hardware पर creator के laptop में test किया गया है
  • build और run की शुरुआत git clone के बाद make run से होती है, और इसके लिए Xorriso, Qemu, NASM, Clang install होने चाहिए
  • TacOS वास्तविक उपयोग के लिए तैयार नहीं है, बल्कि एक hobby toy OS है, जिसमें कई known bugs हैं

TacOS अवलोकन

  • TacOS C और assembly में लिखा गया एक from-scratch OS है, जिसका अपना kernel है
  • यह UNIX-like kernel संरचना पर बना है और DOOM तथा कई छोटे user-space programs चला सकता है
  • इसके मुख्य components इस प्रकार हैं
    • VFS
    • scheduler
    • TempFS
    • devices
    • context switching
    • virtual memory management
    • physical page frame allocation
    • Doom port

execution environment और सीमाएँ

  • TacOS real hardware और Qemu emulator, दोनों पर चल सकता है
  • real hardware testing creator के laptop पर की गई है
  • यह project वास्तविक उपयोग के लिए तैयार पूर्ण OS नहीं, बल्कि एक hobby toy OS है
  • इसमें कई known bugs हैं

quick start

  • build और run निम्न command से किया जा सकता है
git clone https://github.com/UnmappedStack/TacOS
cd TacOS && make run
  • make run TacOS को build करता है और Qemu emulator में अपने-आप run करता है
  • आवश्यक tools इस प्रकार हैं
    • Xorriso
    • Qemu
    • NASM
    • Clang

build commands

  • make run: TacOS को build करता है और Qemu में चलाता है
  • make qemu: पहले से built TacOS को Qemu में चलाता है
  • make disk: पूरी disk image को tacos.iso के रूप में build करता है
  • make kernel: system के core TacOS kernel को build करता है
  • make libc: standard library को build करता है
  • make userspace: user-space applications को build करता है
  • make initrd: system boot के लिए initial ramdisk बनाता है
  • make lint: kernel के लिए linter rules चलाता है
  • make qemu-gdb: GDB connected state में TacOS को Qemu में चलाता है

debugging

  • TacOS test करते समय GDB attach करने के लिए make qemu-gdb चलाएँ, फिर दूसरे terminal में GDB remote target से connect करें
$ gdb -q
(gdb) target remote :1234
(gdb) file kernel/bin/tacos
(gdb) continue
  • kernel debug करते समय kernel/bin/tacos specify करें
  • user-space programs debug करते समय initrd/usr/bin/<program> specify करें

license और contribution rules

  • TacOS Mozilla Public License 2.0 का उपयोग करता है
  • contribution खुले हैं, लेकिन pull request भेजने से पहले issue खोलकर changes assign कराने होंगे
  • केवल simple typo या grammar fixes वाले pull request merge नहीं किए जाएँगे
  • commit message को [component] change format का पालन करना होगा
  • कई unrelated components में हज़ारों lines के changes को एक ही बहुत बड़े commit में रखने वाले pull request review के लिए नहीं लिए जाएँगे

community

  • TacOS updates, OSDev project में मदद, और बातचीत के लिए एक Discord server है

संबंधित पढ़ाई

1 टिप्पणियां

 
GN⁺ 2025-04-26
Hacker News की राय

  • बधाई! आपको गर्व हो रहा होगा, और proof of concept के लिए DOOM चुनना भी बढ़िया है
    शायद सिर्फ़ beginner सवालों से मज़ा थोड़ा कम हो, लेकिन मैं जानना चाहूंगा कि इसे laptop पर चलाने के लिए क्या steps चाहिए
    build करने के बाद क्या प्रक्रिया Windows PC पर dual boot setup करने जैसी होती है? थोड़ा मज़ेदार है कि मैं internet के किसी अजनबी से अपने computer पर risky software चलाने का तरीका पूछ रहा हूं
    अगर कोई ऐसा project करना चाहे, तो क्या कोई textbook या पढ़ने लायक material recommend करेंगे? university में मैंने operating systems और related courses लिए थे, लेकिन electrical engineering major होने के कारण सब कुछ काफ़ी abstract और concept-heavy था. कुछ ज़्यादा concrete material अच्छा रहेगा, और ज़रूरी नहीं कि वह x64 ही हो

    • बिल्कुल भी मज़ा कम नहीं होता! मैंने इसे अपने laptop पर जिस तरह चलाया, वह सचमुच बस USB को ISO से format करना और USB से boot करना था
      अगर आप kernel लिखना चाहते हैं, तो पहले https://osdev.wiki देखने की सलाह दूंगा, और Intel Developer Manual जैसी relevant specifications और जिन drivers को आप खुद लिखेंगे उनकी specifications भी पढ़नी होंगी
      x86 के अलावा kernel development के बारे में मुझे ज़्यादा नहीं पता, लेकिन जहां तक मुझे मालूम है, concepts ज़्यादातर same रहते हैं और सिर्फ़ technical implementation अलग होता है. project README में Discord server का link है, और वहां वाकई बहुत smart लोग हैं जो खुशी से मदद करेंगे
    • मैंने भी एक kernel लिखा है, हालांकि वह अभी पूरा नहीं हुआ है, और मैंने अपने सभी steps document किए हैं. कई लोगों ने इसे useful बताया है: https://0xc0ffee.netlify.app/osdev

  • अच्छा है, लेकिन क्या तुम्हारा taco भी DOOM चला सकता है?
    मज़ाक अलग, यह सच में तारीफ़ के काबिल effort है और बढ़िया काम है! मेरा सवाल यह है कि TacOS बनाते समय आपने DOOM को standard goal जैसा रखा था, या शुरुआत से ही लक्ष्य ऐसा dedicated operating system बनाना था जो सिर्फ़ DOOM चलाए
    सिर्फ़ curiosity में पूछ रहा हूं. करीब 30 साल पहले मैंने learning और fun के लिए एक बेहद barebones operating system बनाया था जो बस boot होता था, लेकिन अगर ऐसा dedicated operating system हो जो practically सिर्फ़ DOOM चला सके और हर जगह port हो सके, तो “क्या इस पर DOOM चलता है?” meme और भी ज़्यादा ironic और मज़ेदार हो जाएगा
    शानदार काम है, इसे जारी रखें

    • यह सिर्फ़ Doom ही नहीं चला सकता; वह बस सबसे हाल में port किया गया milestone है
      Doom को चलाने में, libc requirements जोड़ने सहित, लगभग एक हफ्ता लगा, और उससे पहले बिछाई गई foundation work कहीं ज़्यादा थी
      मैंने DoomGeneric इस्तेमाल किया, जो मूल रूप से Doom का बहुत portable fork है. उम्मीद है आपके सवाल का जवाब मिल गया होगा, हालांकि हो सकता है मैंने गलत समझा हो

  • scratch से बनाए गए kernel से सीधे DOOM तक पहुंचना top-tier hacker badge जैसा काम है. इसे real hardware पर चलते देखना सच में खुशी देने वाला होगा और बहुत शानदार है

    • real hardware पर चलते देखना काफ़ी खुशी देता है. kernel ठीक-ठीक सीधे Doom में नहीं जाता; यह shell में boot होता है और फिर वहां से Doom चला सकते हैं

  • थोड़ा tangent है, लेकिन मैं भी कुछ ऐसा ही सोच रहा था. जानना चाहता हूं कि modern PC hardware पर directly boot होने वाले game बनाने की कितनी कोशिशें हुई हैं
    यानी पूरा operating system load किए बिना सीधे game में जाना, पुराने generation के game consoles जैसा. इसे simple रखना हो तो Wi-Fi, Bluetooth, GPU जैसी चीज़ों को modern drivers के बिना use करना मुश्किल होगा, लेकिन keyboard और mouse के लिए basic BIOS access जैसी चीज़ें हैं, तो यह काफ़ी possible लगता है. हो सकता है terminology गलत हो, लेकिन उम्मीद है बात समझ आ गई होगी

    • पता नहीं इसका ज़्यादा use हुआ है या नहीं, लेकिन यह known तरीका है और काम करता है. शुरुआती x86-16 assembly experiments में मैंने ऐसा किया था, लेकिन आखिर में qemu से आसान emulator dosbox-staging इस्तेमाल करने के लिए DOS को program launcher की तरह use करने लगा
      अगर आप disk I/O में नहीं जाना चाहते, तो बड़ी limitation 512 bytes से कम होना है. असल में आप program को master boot record की तरह चला रहे होते हैं. अगर ज़्यादा space चाहिए, तो disk से कुछ LBA पढ़ने होंगे, इसके लिए interrupts भी हैं और osdev पर बेहतर material भी है
      इसके अलावा .com files, आमतौर पर 64KB single-segment limit, और MBR-style bootable programs के बीच फर्क काफ़ी छोटा है

  • सच में शानदार काम है. काश मेरे पास भी ऐसा करने की skill होती, लेकिन इसे कर पाने के लिए आपको बहुत सारी specifications पढ़नी पड़ी होंगी, और वही मेरी सबसे कमजोर side है
    शायद बेवकूफी भरा सवाल हो, लेकिन अगर मैं GPU acceleration का बहुत छोटा सा रूप भी use करना चाहूं, तो GPU driver बनाना कितना मुश्किल होगा? क्या उसके documentation को अच्छा मानते हैं?

    • वह शायद operating system development की extreme territory होगी, और कम से कम ऐसी GPU के लिए driver जिसे सच में खरीदा जा सके, मैं भी शायद नहीं कर पाऊंगा
      Qemu की emulated GPU का documentation काफ़ी ठीक है, इसलिए वह possible हो सकता है, लेकिन Nvidia GPU जैसी चीज़ों का documentation खराब है और हाल तक documentation पूरी तरह closed था. Linux भी इस issue से जूझता है, और मैंने कुछ hobby OS developers को अंत में Linux के GPU drivers उठाकर use करते देखा है
      मैंने बहुत सी चीज़ों को almost impossible के रूप में mark नहीं किया है, लेकिन common GPUs के लिए सच में अच्छा GPU driver लिखना honestly मुझे नहीं लगता कि मैं कभी कर पाऊंगा

  • unmapped, नमस्ते, मैं GitHub और Discord पर ThatOSDeveloper के नाम से हूं और वही मेरा display name है. मुझे नहीं पता था कि आपने TacOS पर Doom चला लिया है, यह काफ़ी cool है
    कुछ बातें जाननी हैं. क्या यह original Doom है, disk पर है या initramfs में, और आप जिस engine का use कर रहे हैं उसके साथ Freedoom इस्तेमाल कर रहे हैं या shareware Doom WAD?

    • जैसा post में दिखता है, यह doomgeneric है, और इस page के top पर दिखने के अनुसार changes काफ़ी कम हैं
    • Doom के portable fork DoomGeneric का use किया है. यह initrd से load किए गए TempFS पर है, और doom1.wad इस्तेमाल करता है

  • बहुत cool है, लेकिन आजकल low-level और memory-safe languages मौजूद हैं, तो आपने unsafe language क्यों चुनी, यह जानना चाहता हूं. हम सब पहले से जानते हैं कि security bugs में से अधिकांश memory-related होते हैं
    समझता हूं कि यह hobby project है, लेकिन जब बेहतर alternatives हैं, तो समझ नहीं आता कि हम unsafe languages को retire क्यों नहीं करते

    • मुख्य वजह यह है कि C कहीं ज़्यादा simple है, और kernel development में simplicity ही सब कुछ है
      दूसरे projects में मैंने Rust use किया है, लेकिन kernel development में मुझे safe language की तुलना में simple और पढ़ने में आसान language इस्तेमाल करने की इच्छा कहीं ज़्यादा होती है

  • club में स्वागत है! मैंने भी लगभग यही काम किया है, और ऐसी चीज़ बनाने की शांति का सच में आनंद लिया जिसका product बनने की कोई संभावना नहीं थी
    https://jakobbr.eu/2024/08/19/writing-my-own-x86_64-operatin...

  • सच में शानदार project है! जानना चाहता हूं कि TacOS में process isolation और scheduling कैसे handle करते हैं

    • virtual memory के लिए paging इस्तेमाल करते हैं ताकि हर process का अपना address space हो
      PIT driver से जुड़ा round-robin scheduler है, इसलिए हर 10ms पर PIT interrupt generate करता है और scheduler चलता है. scheduler अगला task चुनता है, पिछले task की current state save करता है, नए address space में switch करता है, stack बदलता है, task के registers restore करता है, और फिर iretq instruction से ring 3 user mode में switch करते हुए instruction pointer पर jump करता है

  • TacOS के बारे में और जानना चाहता हूं. कई programs को एक साथ safely चलाने को कैसे manage करते हैं?