Morok

अल्फ़ा सॉफ़्टवेयर। कोर फ़ंक्शनैलिटी टेस्टेड है, लेकिन APIs अस्थिर हैं और बिना नोटिस के बदल सकते हैं।

Morok एक Rust-आधारित ML कम्पाइलर है जो Tinygrad से प्रेरित है। इसमें UOp-आधारित IR के साथ lazy tensor इवैल्यूएशन, पैटर्न-ड्रिवन ऑप्टिमाइज़ेशन, और मल्टी-बैकएंड कोड जनरेशन शामिल है।

मुख्य विशेषताएँ

विशेषता	विवरण
डिक्लेरेटिव ऑप्टिमाइज़ेशन	Z3-सत्यापित शुद्धता के साथ ग्राफ़ रीराइट्स के लिए patterns! DSL
Lazy इवैल्यूएशन	Tensor कम्प्यूटेशन ग्राफ़ बनाते हैं, कम्पाइल केवल realize() पर होता है
प्रोवेनेंस ट्रैकिंग	#[track_caller] हर UOp को सोर्स लोकेशन तक ट्रेस करता है
80+ IR ऑपरेशन	अरिथमेटिक, मेमोरी, कंट्रोल फ़्लो, WMMA tensor cores
20+ ऑप्टिमाइज़ेशन	कॉन्स्टेंट फ़ोल्डिंग, tensor cores, वेक्टराइज़ेशन, लूप अनरोलिंग

आर्किटेक्चर की डिटेल्स के लिए डॉक्यूमेंटेशन साइट देखें।

वर्कस्पेस

Crate	विवरण
dtype	टाइप सिस्टम: scalars, vectors, pointers, images
macros	प्रोसीज़रल मैक्रोज़ (patterns! DSL)
ir	UOp ग्राफ़ IR: 80+ ops, symbolic integers, प्रोवेनेंस
device	बफ़र मैनेजमेंट: lazy alloc, zero-copy views, LRU कैशिंग
schedule	ऑप्टिमाइज़ेशन इंजन: 20+ पासेज़, RANGEIFY, Z3 वेरिफ़िकेशन
codegen	कोड जनरेशन: Clang (डिफ़ॉल्ट), LLVM JIT, MLIR
runtime	JIT कम्पाइलेशन और कर्नेल एक्ज़ीक्यूशन
tensor	हाई-लेवल lazy tensor API
onnx	ONNX मॉडल इम्पोर्टर
arch	इन्फ़रेंस प्रिमिटिव्स
model	प्री-ट्रेन्ड मॉडल्स

त्वरित उदाहरण

use morok_tensor::Tensor;
use ndarray::array;

// Zero-copy from ndarray (C-contiguous fast path)
let a = Tensor::from_ndarray(&array![[1.0f32, 2.0], [3.0, 4.0]]);
let b = Tensor::from_ndarray(&array![[5.0f32, 6.0], [7.0, 8.0]]);

// Lazy — nothing executes yet
let mut c = &a + &b;
c.realize()?;

// Zero-copy view into the result
let view = c.array_view::<f32>()?;
assert_eq!(view, array![[6.0, 8.0], [10.0, 12.0]].into_dyn());

Pattern DSL उदाहरण

use morok_schedule::patterns;

let optimizer = patterns! {
    // Identity folding (commutative)
    Add[x, @zero] ~> x,
    Mul[x, @one] ~> x,

    // Constant folding
    for op in binary [Add, Mul, Sub] {
        op(a @const(av), _b @const(bv))
          => |a, av, bv| eval_binary_op(op, av, bv).map(|r| UOp::const_(a.dtype(), r)),
    },
};

डेवलपमेंट

एनवायरनमेंट सेटअप

Nix

इस प्रोजेक्ट में सभी डिपेंडेंसीज़ और कम्पाइलर्स के साथ एक प्री-डिफ़ाइंड Nix डेवलपमेंट एनवायरनमेंट है। वही इंफ़्रास्ट्रक्चर CI/CD के लिए इस्तेमाल होता है, इसलिए यह डेवलप और टेस्ट करने का प्रिफ़र्ड तरीका है।

nix develop # Open development shell
nix flake check # Run CI tests
nix fmt # Format source files

बेयर मेटल

डिपेंडेंसी	वर्शन	ज़रूरी	विवरण
Rust	1.85+	हाँ	Edition 2024
LLVM	21.x	हाँ	CPU कोड जनरेशन बैकएंड
Clang	-	हाँ	LLVM बिल्ड्स के लिए C कम्पाइलर
pkgconf	-	हाँ	बिल्ड कॉन्फ़िगरेशन टूल
protobuf	-	हाँ	ONNX proto कम्पाइलेशन
zlib	>=1.3	हाँ	कम्प्रेशन लाइब्रेरी
libffi	>=3.4	हाँ	फ़ॉरेन फ़ंक्शन इंटरफ़ेस
libxml2	>=2.13	हाँ	XML पार्सिंग
Z3	>=4.15	नहीं	ऑप्टिमाइज़ेशन वेरिफ़िकेशन के लिए SMT सॉल्वर

टेस्ट

cargo test
cargo test --features z3,proptest  # With Z3 verification and PB generated tests
cargo test --features cuda   # With CUDA tests