लुआ (प्रोग्रामिंग भाषा)

हांग और कमजोर टाइपिंग, बतख टाइपिंग MoonSharp, [//luvit.io Luvit], [//www.luart.org LuaRT], Luau | विकिबुक्स = }}
 * कार्यान्वयन = [//www.lua.org/download.html Lua], LuaJIT, [//eliasdaler.github.io/luavela/ LuaVela],
 * प्रोग्रामिंग_भाषा = एएनएसआई सी
 * बोलियाँ = Metalua, आइडल, जीएसएल शेल
 * impact_by = C++, CLU (प्रोग्रामिंग भाषा), Modula-2, योजना (प्रोग्रामिंग भाषा), SNOBOL
 * प्रभावित = GameMonkey Script, आयो (प्रोग्रामिंग भाषा), जावास्क्रिप्ट, जूलिया (प्रोग्रामिंग भाषा), मिनी डी, लाल (प्रोग्रामिंग भाषा), रिंग_ (प्रोग्रामिंग_भाषा), रूबी (प्रोग्रामिंग भाषा), गिलहरी (प्रोग्रामिंग भाषा), मूनस्क्रिप्ट, सी--
 * ऑपरेटिंग_सिस्टम = क्रॉस-प्लेटफॉर्म
 * लाइसेंस = मेरा लाइसेंस
 * वेबसाइट =
 * फ़ाइल एक्सट =

लुआ (से lua मीनिंग चांद) एक हल्की प्रोग्रामिंग भाषा है, उच्च-स्तरीय प्रोग्रामिंग भाषा | उच्च-स्तरीय, बहु-प्रतिमान प्रोग्रामिंग भाषा जिसे मुख्य रूप से अनुप्रयोगों में स्क्रिप्टिंग भाषा के लिए डिज़ाइन किया गया है। लुआ क्रॉस-प्लेटफ़ॉर्म है, चूंकि संकलक बाईटकोड का इंटरप्रेटर (कंप्यूटिंग) एएनएसआई सी में लिखा गया है, और लुआ के पास इसे अनुप्रयोगों में एम्बेड करने के लिए अपेक्षाकृत सरल सी एपीआई है। लुआ की उत्पत्ति 1993 में उस समय अनुकूलन की बढ़ती मांग को पूरा करने के लिए अनुप्रयोग प्रक्रिया सामग्री के विस्तार के लिए एक भाषा के रूप में हुई थी। इसने अधिकांश प्रक्रियात्मक प्रोग्रामिंग भाषाओं की बुनियादी सुविधाएं प्रदान कीं, लेकिन अधिक जटिल या डोमेन-विशिष्ट भाषा|डोमेन-विशिष्ट सुविधाओं को शामिल नहीं किया गया; बल्कि, इसमें भाषा का विस्तार करने के लिए तंत्र शामिल थे, जिससे प्रोग्रामर ऐसी सुविधाओं को लागू कर सकें। जैसा कि लुआ को एक सामान्य एम्बेड करने योग्य विस्तार भाषा बनाने का इरादा था, लुआ के डिजाइनरों ने इसकी रूपरेखा (कंप्यूटर प्रोग्रामिंग), में porting, एक्स्टेंसिबिलिटी और विकास में उपयोग में आसानी पर ध्यान केंद्रित किया।

इतिहास
लुआ को 1993 में ब्राज़िल में रियो डी जनेरियो के परमधर्मपीठीय कैथोलिक विश्वविद्यालय में कंप्यूटर ग्राफिक्स टेक्नोलॉजी ग्रुप (टेक्ग्राफ) के सदस्य रॉबर्टो इरुसलिम्स्की, लुइज़ हेनरिक डी फिगुएरेडो और वाल्डेमर सेलेस द्वारा बनाया गया था।

1977 से 1992 तक, ब्राजील में कंप्यूटर हार्डवेयर और सॉफ्टवेयर के लिए मजबूत व्यापार बाधाओं (जिसे मार्केट रिजर्व कहा जाता है) की नीति थी। उस माहौल में, टेकग्राफ के ग्राहक राजनीतिक या आर्थिक रूप से विदेश से अनुकूलित सॉफ्टवेयर खरीदने का जोखिम नहीं उठा सकते थे। उन कारणों ने टेकग्राफ को खरोंच से आवश्यक बुनियादी उपकरणों को लागू करने के लिए प्रेरित किया। लुआ के पूर्ववर्ती डेटा-विवरण/कॉन्फ़िगरेशन भाषाएँ SOL (सिंपल ऑब्जेक्ट लैंग्वेज) और DEL (डेटा-एंट्री भाषा) थीं। वे 1992-1993 में टेकग्राफ में दो अलग-अलग परियोजनाओं में कुछ लचीलापन जोड़ने के लिए स्वतंत्र रूप से विकसित किए गए थे (दोनों पेट्रोब्रास कंपनी में इंजीनियरिंग अनुप्रयोगों के लिए इंटरैक्टिव ग्राफिकल प्रोग्राम थे)। एसओएल और डीईएल में किसी भी प्रवाह-नियंत्रण संरचनाओं की कमी थी, और पेट्रोब्रास ने उन्हें पूर्ण प्रोग्रामिंग शक्ति जोड़ने की बढ़ती आवश्यकता महसूस की।

लुआ के विकास में, भाषा के लेखकों ने लिखा:

"In 1993, the only real contender was Tcl, which had been explicitly designed to be embedded into applications. However, Tcl had unfamiliar syntax, did not offer good support for data description, and ran only on Unix platforms. We did not consider LISP or Scheme because of their unfriendly syntax. Python was still in its infancy. In the free, do-it-yourself atmosphere that then reigned in Tecgraf, it was quite natural that we should try to develop our own scripting language ... Because many potential users of the language were not professional programmers, the language should avoid cryptic syntax and semantics. The implementation of the new language should be highly portable, because Tecgraf's clients had a very diverse collection of computer platforms. Finally, since we expected that other Tecgraf products would also need to embed a scripting language, the new language should follow the example of SOL and be provided as a library with a C API."

लुआ 1.0 को इस तरह से डिजाइन किया गया था कि इसके ऑब्जेक्ट कंस्ट्रक्टर्स, वर्तमान प्रकाश और लचीली शैली से थोड़ा अलग होने के कारण, एसओएल के डेटा-विवरण सिंटैक्स को शामिल किया गया (इसलिए नाम लुआ: सोल का अर्थ पुर्तगाली में सूर्य, और लुआ का अर्थ चंद्रमा). नियंत्रण संरचनाओं के लिए लुआ सिंटेक्स (प्रोग्रामिंग भाषाएं) ज्यादातर मापांक से उधार लिया गया था (, ,  / ), लेकिन सीएलयू (प्रोग्रामिंग लैंग्वेज) (कई असाइनमेंट और फ़ंक्शन कॉल से कई रिटर्न, संदर्भ या स्पष्ट सूचक (कंप्यूटर प्रोग्रामिंग) द्वारा कॉल करने के लिए एक सरल विकल्प के रूप में), सी ++ (एक स्थानीय चर को अनुमति देने का साफ विचार) से भी प्रभावित हुआ था। केवल वहीं घोषित किया जाए जहां हमें इसकी आवश्यकता है ), SNOBOL और AWK (सहयोगी सरणियाँ)। डॉ. डॉब के जर्नल में प्रकाशित एक लेख में, लुआ के रचनाकारों ने यह भी कहा कि एलआईएसपी और योजना उनके एकल, सर्वव्यापी डेटा-संरचना तंत्र (सूची (सार डेटा प्रकार)) के साथ तालिका को प्राथमिक के रूप में विकसित करने के उनके निर्णय पर एक बड़ा प्रभाव था। लुआ की डेटा संरचना। लुआ अर्थ विज्ञान समय के साथ योजना से तेजी से प्रभावित हुए हैं, विशेष रूप से अनाम कार्यों और पूर्ण स्कोप (कंप्यूटर विज्ञान) # लेक्सिकल स्कोप बनाम डायनेमिक स्कोप की शुरुआत के साथ। नए लुआ संस्करणों में कई सुविधाएँ जोड़ी गईं।

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

सुविधाएँ
लुआ को आमतौर पर बहु-प्रतिमान प्रोग्रामिंग भाषा के रूप में वर्णित किया जाता है। बहु-प्रतिमान भाषा, सामान्य सुविधाओं का एक छोटा सा सेट प्रदान करती है जिसे विभिन्न प्रकार की समस्या के लिए बढ़ाया जा सकता है। लुआ में वंशानुक्रम (वस्तु-उन्मुख प्रोग्रामिंग) के लिए स्पष्ट समर्थन नहीं है, लेकिन इसे मेटाटेबल्स के साथ लागू करने की अनुमति देता है। इसी तरह, लुआ प्रोग्रामर्स को नामस्थान, क्लास (कंप्यूटर प्रोग्रामिंग), और अन्य संबंधित विशेषताओं को इसके एकल टेबल कार्यान्वयन का उपयोग करने की अनुमति देता है; प्रथम श्रेणी के कार्य कार्यात्मक प्रोग्रामिंग से कई तकनीकों के रोजगार की अनुमति देते हैं; और पूर्ण लेक्सिकल स्कूपिंग कम से कम विशेषाधिकार के सिद्धांत को लागू करने के लिए ठीक-ठाक जानकारी को छिपाने की अनुमति देता है।

सामान्य तौर पर, लुआ सरल, लचीला मेटाप्रोग्रामिंग प्रदान करने का प्रयास करता है| परिणामस्वरूप, आधार भाषा लाइटवेट प्रोग्रामिंग भाषा है—पूर्ण संदर्भ दुभाषिया (कंप्यूटिंग) केवल लगभग 247 किलोबाइट संकलित है -और अनुप्रयोगों की एक विस्तृत श्रृंखला के लिए आसानी से अनुकूलनीय।

विस्तार भाषा या स्क्रिप्टिंग भाषा के रूप में उपयोग के लिए एक गतिशील रूप से टाइप की गई भाषा, लुआ विभिन्न प्रकार के होस्ट प्लेटफॉर्म पर फिट होने के लिए पर्याप्त कॉम्पैक्ट है। यह बूलियन डेटा प्रकार मान, संख्या (डबल-परिशुद्धता तैरनेवाला स्थल और डिफ़ॉल्ट रूप से 64-बिट पूर्णांक), और स्ट्रिंग (कंप्यूटर विज्ञान) जैसे परमाणु डेटा संरचनाओं की एक छोटी संख्या का समर्थन करता है। विशिष्ट डेटा संरचनाएं जैसे कि एरे डेटा संरचना, सेट (कंप्यूटर विज्ञान), सूची (कंप्यूटिंग), और रिकॉर्ड (कंप्यूटर विज्ञान) को लुआ की एकल मूल डेटा संरचना, तालिका का उपयोग करके प्रदर्शित किया जा सकता है, जो अनिवार्य रूप से एक विषम साहचर्य सरणी है।

लुआ उन्नत सुविधाओं के एक छोटे सेट को लागू करता है जैसे प्रथम श्रेणी के कार्य, कचरा संग्रह (कंप्यूटर विज्ञान), क्लोजर (कंप्यूटर विज्ञान), उचित पूंछ की पुनरावृत्ति, प्रकार रूपांतरण (रन टाइम पर स्ट्रिंग और संख्या मानों के बीच स्वत: रूपांतरण), कोरटाइन (सहकारी) मल्टीटास्किंग) और गतिशील लोडिंग।

सिंटेक्स
क्लासिक हैलो, वर्ल्ड! कार्यक्रम को इस प्रकार लिखा जा सकता है: <वाक्यविन्यास लैंग = लुआ> प्रिंट (हैलो, वर्ल्ड!)  या के रूप में: <वाक्यविन्यास लैंग = लुआ> प्रिंट 'हैलो, वर्ल्ड!' 

लुआ में एक टिप्पणी (कंप्यूटर प्रोग्रामिंग) एक डबल-हाइफ़न के साथ शुरू होती है और एडा (प्रोग्रामिंग भाषा), एफिल (प्रोग्रामिंग भाषा), हास्केल (प्रोग्रामिंग भाषा), एसक्यूएल और वीएचडीएल के समान लाइन के अंत तक चलती है। बहु-पंक्ति तार और टिप्पणियाँ दोहरे वर्ग कोष्ठक से सुशोभित हैं।कारख़ाने का फ़ंक्शन को इस उदाहरण में एक फ़ंक्शन के रूप में लागू किया गया है: <वाक्यविन्यास लैंग = लुआ> समारोह फैक्टोरियल (एन) स्थानीय एक्स = 1 मैं = 2 के लिए, एन करते हैं एक्स = एक्स * मैं समाप्त वापसी एक्स समाप्त 

नियंत्रण प्रवाह
लुआ में एक प्रकार की सशर्त (कंप्यूटर प्रोग्रामिंग) परीक्षा है:  वैकल्पिक के साथ   तथा   निष्पादन नियंत्रण निर्माण।

सामान्य  कथन के लिए तीनों खोजशब्दों की आवश्यकता है: <वाक्यविन्यास लैंग = लुआ> अगर शर्त है तो --स्टेटमेंट बॉडी समाप्त   निष्पादन को नियंत्रित करने के लिए ई> कीवर्ड को एक साथ स्टेटमेंट ब्लॉक के साथ जोड़ा जा सकता है   स्थिति का मूल्यांकन करता है  : <वाक्यविन्यास लैंग = लुआ> अगर शर्त है तो --स्टेटमेंट बॉडी वरना --स्टेटमेंट बॉडी समाप्त 

का उपयोग करके कई शर्तों के अनुसार निष्पादन को भी नियंत्रित किया जा सकता है  खोजशब्द: <वाक्यविन्यास लैंग = लुआ> अगर शर्त है तो --स्टेटमेंट बॉडी अन्य स्थिति तब --स्टेटमेंट बॉडी अन्य - वैकल्पिक --वैकल्पिक डिफ़ॉल्ट स्टेटमेंट बॉडी समाप्त 

लुआ में चार प्रकार के कंडीशनल लूप होते हैं: जबकि लूप| लूप, द   लूप (लूप के दौरान डू के समान |  लूप), लूप के लिए न्यूमेरिक |  लूप, और जेनेरिक   फंदा।

<वाक्यविन्यास लैंग = लुआ> --स्थिति = सत्य

जबकि हालत करते हैं --बयान समाप्त

दोहराना --बयान स्थिति तक

for i = first, last, delta do --delta नेगेटिव हो सकता है, जिससे for लूप काउंट डाउन या अप हो सकता है --बयान --उदाहरण: प्रिंट (मैं) समाप्त 

सामान्य  फंदा: <वाक्यविन्यास लैंग = लुआ> कुंजी के लिए, जोड़े में मान (_G) करते हैं प्रिंट (कुंजी, मान) समाप्त  मेज पर पुनरावृति करेंगे  मानक इटरेटर फ़ंक्शन का उपयोग करना , जब तक यह वापस नहीं आता.

लूप नेस्टिंग (प्रोग्रामिंग) भी हो सकते हैं (दूसरे लूप के अंदर डालें)।

<वाक्यविन्यास लैंग = लुआ> स्थानीय ग्रिड = { {11, 12, 13}, {21, 22, 23},  {31, 32, 33} }

वाई के लिए, जोड़े में पंक्ति (ग्रिड) करते हैं एक्स के लिए, जोड़े में मूल्य (पंक्ति) करते हैं प्रिंट (एक्स, वाई, मान) समाप्त समाप्त 

कार्य
प्रथम श्रेणी के फ़ंक्शन के रूप में लुआ के कार्यों का उपचार | प्रथम श्रेणी के मान निम्न उदाहरण में दिखाए गए हैं, जहां प्रिंट फ़ंक्शन का व्यवहार संशोधित किया गया है: <वाक्यविन्यास लैंग = लुआ> करना स्थानीय ओल्डप्रिंट = प्रिंट - पुराने प्रिंट के रूप में वर्तमान प्रिंट फ़ंक्शन को स्टोर करें फ़ंक्शन प्रिंट - प्रिंट फ़ंक्शन को फिर से परिभाषित करें। सामान्य प्रिंट फ़ंक्शन का अभी भी उपयोग किया जा सकता है ओल्डप्रिंट के माध्यम से। नए के पास केवल एक तर्क है। ओल्डप्रिंट (एस == फू और बार या एस) समाप्त समाप्त  कोई भविष्य कॉल करता है  अब नए फ़ंक्शन के माध्यम से रूट किया जाएगा, और लुआ के स्कोप (प्रोग्रामिंग) # लेक्सिकल स्कोपिंग के कारण, पुराना प्रिंट फ़ंक्शन केवल नए, संशोधित प्रिंट द्वारा ही एक्सेस किया जा सकेगा।

लुआ क्लोजर (कंप्यूटर प्रोग्रामिंग) का भी समर्थन करता है, जैसा कि नीचे दिखाया गया है: <वाक्यविन्यास लैंग = लुआ> समारोह जोड़ (एक्स) - एक नया फ़ंक्शन लौटाएं जो तर्क में x जोड़ता है वापसी समारोह (वाई) --[=[ जब हम वेरिएबल x को संदर्भित करते हैं, जो वर्तमान के बाहर है दायरा और जिसका जीवनकाल इस गुमनाम से कम होगा कार्य, लुआ एक बंद बनाता है।] =] रिटर्न एक्स + वाई समाप्त समाप्त फोरप्लस = जोड़ (4) प्रिंट (फोरप्लस (3)) - प्रिंट 7

- यह फ़ंक्शन को निम्न तरीके से कॉल करके भी प्राप्त किया जा सकता है: प्रिंट (जोड़ें (4) (3)) - ऐसा इसलिए है क्योंकि हम सीधे '3' तर्क के साथ 'एडटो (4)' से लौटे फ़ंक्शन को कॉल कर रहे हैं। यह डेटा लागत को कम करने और प्रदर्शन को बेहतर बनाने में भी मदद करता है यदि इसे पुनरावृत्त रूप से कहा जाता है।

 चर के लिए एक नया समापन  हर बार बनाया जाता है   कहा जाता है, ताकि लौटाया गया प्रत्येक नया अज्ञात फ़ंक्शन हमेशा स्वयं का उपयोग करेगा   पैरामीटर। बंद करने का प्रबंधन लुआ के कचरा संग्राहक द्वारा किया जाता है, किसी अन्य वस्तु की तरह।

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

तालिका कुंजी और डेटा जोड़े का एक संग्रह है, जहां डेटा को कुंजी द्वारा संदर्भित किया जाता है; दूसरे शब्दों में, यह एक हैश तालिका विषम साहचर्य सरणी है।

का उपयोग करके तालिकाएँ बनाई जाती हैं  कंस्ट्रक्टर सिंटैक्स।

<वाक्यविन्यास लैंग = लुआ> a_table = {} -- एक नया, खाली टेबल बनाता है 

तालिकाएँ हमेशा संदर्भ द्वारा पारित की जाती हैं (देखें साझा करके कॉल करें)।

एक कुंजी (इंडेक्स) को छोड़कर कोई भी मूल्य हो सकता है  और NaN, कार्यों सहित।

<वाक्यविन्यास लैंग = लुआ> a_table = {x = 10} - संख्या 10 पर एक प्रविष्टि मैपिंग x के साथ एक नई तालिका बनाता है। प्रिंट (a_table [ x ]) - स्ट्रिंग कुंजी से जुड़े मान को प्रिंट करता है, इस मामले में 10। बी_टेबल = ए_टेबल b_table[ x ] = 20 -- तालिका में मान को 20 में बदल दिया गया है। प्रिंट (b_table [ x ]) - 20 प्रिंट करता है। प्रिंट (a_table [ x ]) - 20 भी प्रिंट करता है, क्योंकि a_table और b_table दोनों एक ही टेबल को संदर्भित करते हैं। 

कुंजी के रूप में स्ट्रिंग (कंप्यूटर विज्ञान) का उपयोग करके एक तालिका को अक्सर वस्तु रचना (या रिकॉर्ड (कंप्यूटर विज्ञान)) के रूप में उपयोग किया जाता है। क्योंकि इस तरह का उपयोग बहुत आम है, लुआ ऐसे क्षेत्रों तक पहुँचने के लिए एक विशेष सिंटैक्स पेश करता है। <वाक्यविन्यास लैंग = लुआ> बिंदु = {x = 10, y = 20} -- नई तालिका बनाएँ प्रिंट (प्वाइंट [ x ]) - 10 प्रिंट करता है प्रिंट (प्वाइंट.एक्स) - ऊपर की रेखा के समान ही अर्थ है। आसानी से पढ़ा जाने वाला डॉट नोटेशन सिंटैक्टिक शुगर है। 

संबंधित कार्यों को संग्रहीत करने के लिए तालिका का उपयोग करके, यह नामस्थान के रूप में कार्य कर सकता है।

<वाक्यविन्यास लैंग = लुआ> बिंदु = {}

प्वाइंट.न्यू = फंक्शन (एक्स, वाई) वापसी {x = x, y = y} - वापसी {[x] = x, [y] = y} समाप्त

प्वाइंट.सेट_एक्स = फ़ंक्शन (बिंदु, एक्स) बिंदु। एक्स = एक्स - बिंदु [एक्स] = एक्स; समाप्त 

टेबल्स को स्वचालित रूप से एक संख्यात्मक कुंजी असाइन की जाती है, जिससे उन्हें सरणी डेटा प्रकार के रूप में उपयोग करने में सक्षम बनाया जाता है। पहला स्वचालित सूचकांक 0 के बजाय 1 है क्योंकि यह कई अन्य प्रोग्रामिंग भाषाओं के लिए है (हालांकि 0 के स्पष्ट सूचकांक की अनुमति है)।

एक संख्यात्मक कुंजी  एक स्ट्रिंग कुंजी से अलग है.

<वाक्यविन्यास लैंग = लुआ> सरणी = {ए, बी, सी, डी} - सूचकांक स्वचालित रूप से असाइन किए जाते हैं। प्रिंट (सरणी [2]) - प्रिंट बी। लुआ में स्वचालित अनुक्रमण 1 से शुरू होता है। प्रिंट (#array) - प्रिंट 4. # टेबल और स्ट्रिंग्स के लिए लंबाई ऑपरेटर है। सरणी [0] = z - शून्य एक कानूनी सूचकांक है। प्रिंट (# सरणी) - अभी भी 4 प्रिंट करता है, क्योंकि लुआ सरणियाँ 1-आधारित हैं। 

एक टेबल की लंबाई  किसी भी पूर्णांक सूचकांक के रूप में परिभाषित किया गया है   ऐसा है कि   नहीं है   तथा   है  ; इसके अलावा, अगर   है ,   शून्य हो सकता है। एक नियमित सरणी के लिए, 1 से दिए गए गैर-शून्य मानों के साथ  , इसकी लंबाई बिल्कुल इतनी ही है  , इसके अंतिम मूल्य का सूचकांक। यदि सरणी में छेद हैं (अर्थात, अन्य गैर-शून्य मानों के बीच शून्य मान), तो   a से सीधे पहले आने वाला कोई भी सूचकांक हो सकता है   मूल्य (अर्थात, यह सरणी के अंत के रूप में ऐसे किसी भी शून्य मान पर विचार कर सकता है)। <वाक्यविन्यास लैंग = लुआ> उदाहरण टेबल = { {1, 2, 3, 4},  {5, 6, 7, 8} } प्रिंट (उदाहरण तालिका [1] [3]) - प्रिंट 3 प्रिंट (उदाहरण तालिका [2] [4]) - प्रिंट 8 </वाक्यविन्यास हाइलाइट>

एक तालिका वस्तुओं की एक सरणी हो सकती है।

<वाक्यविन्यास लैंग = लुआ> फ़ंक्शन प्वाइंट (एक्स, वाई) - प्वाइंट ऑब्जेक्ट कन्स्ट्रक्टर वापसी {x = x, y = y} - एक नई वस्तु (तालिका) बनाता है और वापस करता है समाप्त सरणी = {प्वाइंट (10, 20), प्वाइंट (30, 40), प्वाइंट (50, 60)} - बिंदुओं की सरणी बनाता है - सरणी = {{x = 10, y = 20}, {x = 30, y = 40}, {x = 50, y = 60}}; प्रिंट (सरणी [2] .y) - प्रिंट 40 </वाक्यविन्यास हाइलाइट>

किसी सरणी का अनुकरण करने के लिए हैश मैप का उपयोग करना सामान्य रूप से वास्तविक सरणी का उपयोग करने की तुलना में धीमा होता है; हालाँकि, इस समस्या से बचने में मदद करने के लिए लुआ तालिकाओं को सरणियों के रूप में उपयोग करने के लिए अनुकूलित किया गया है।<ref name=lobject_h_array></रेफरी>

मेटाटेबल्स
एक्स्टेंसिबल शब्दार्थ लुआ की एक प्रमुख विशेषता है, और मेटाटेबल अवधारणा तालिकाओं के शक्तिशाली अनुकूलन की अनुमति देती है। निम्न उदाहरण एक अनंत तालिका प्रदर्शित करता है। किसी के लिए,   दे देंगे  गतिशील प्रोग्रामिंग और memoization का उपयोग करते हुए -वां फाइबोनैचि संख्या। <वाक्यविन्यास लैंग = लुआ> तंतु = {1, 1} -- तंतु [1] और तंतु [2] के लिए प्रारंभिक मूल्य। सेटमेटेटेबल (फ़ाइब, { __index = function(values, n) --__index लुआ द्वारा पूर्वनिर्धारित एक फ़ंक्शन है,                                                   इसे कहा जाता है अगर कुंजी एन मौजूद नहीं है।    मान [n] = मान [n - 1] + मान [n - 2] - तंतुओं की गणना करें और याद रखें [n]।    वापसी मूल्य [एन]  समाप्त }) </वाक्यविन्यास हाइलाइट>

वस्तु-उन्मुख प्रोग्रामिंग
हालांकि लुआ में कक्षा (कंप्यूटर विज्ञान) की एक अंतर्निहित अवधारणा नहीं है, वस्तु-उन्मुख प्रोग्रामिंग को कार्यों और तालिकाओं का उपयोग करके अनुकरण किया जा सकता है। टेबल में मेथड्स और फील्ड्स डालकर ऑब्जेक्ट बनाया जाता है। इनहेरिटेंस (वस्तु उन्मुख कार्यकर्म) (सिंगल और मल्टीपल दोनों) को मेटाटेबल्स के साथ लागू किया जा सकता है, गैर-मौजूद तरीकों और फ़ील्ड्स को पैरेंट ऑब्जेक्ट के रूप में प्रस्तुत किया जा सकता है।

इन तकनीकों के साथ वर्ग जैसी कोई अवधारणा नहीं है; बल्कि, स्व (प्रोग्रामिंग भाषा) या जावास्क्रिप्ट के समान, प्रोटोटाइप-आधारित प्रोग्रामिंग का उपयोग किया जाता है। नई वस्तुओं को या तो फ़ैक्टरी विधि पैटर्न (जो स्क्रैच से नई वस्तुओं का निर्माण करता है) या किसी मौजूदा वस्तु का क्लोन बनाकर बनाया जाता है।

एक बुनियादी वेक्टर (ज्यामिति) वस्तु बनाना: <वाक्यविन्यास लैंग = लुआ> स्थानीय वेक्टर = {} स्थानीय वेक्टरमेटा = {__इंडेक्स = वेक्टर}

फ़ंक्शन वेक्टर.न्यू (एक्स, वाई, जेड) - निर्माता रिटर्न सेटमेटेबल ({x = x, y = y, z = z}, वेक्टरमेटा) समाप्त

समारोह वेक्टर.परिमाण (स्वयं) - एक और तरीका वापसी गणित.sqrt(self.x^2 + self.y^2 + self.z^2) समाप्त

स्थानीय vec = वेक्टर.नया (0, 1, 0) - एक वेक्टर बनाएं प्रिंट (vec.magnitude (vec)) - एक विधि कॉल करें (आउटपुट: 1) प्रिंट (vec.x) - एक सदस्य चर तक पहुँचें (आउटपुट: 0) </वाक्यविन्यास हाइलाइट>

यहां, setmetatable लुआ को एक तत्व की तलाश करने के लिए कहता है Vector तालिका में यदि यह मौजूद नहीं है vec मेज़। vec.magnitude, जो बराबर है vec["magnitude"], पहले में दिखता है vec के लिए तालिका magnitude तत्व। vec }} टेबल में a नहीं है magnitude तत्व, लेकिन इसके मेटाटेबल प्रतिनिधि Vector के लिए तालिका magnitude तत्व जब यह में नहीं पाया जाता है vec मेज़।

लुआ ऑब्जेक्ट ओरिएंटेशन को सुविधाजनक बनाने के लिए कुछ सिंटैक्टिक चीनी प्रदान करता है। एक प्रोटोटाइप टेबल के अंदर मेथड (कंप्यूटर साइंस) घोषित करने के लिए, कोई भी उपयोग कर सकता है function table:func(args), जो बराबर है function table.func(self, args). कॉलिंग क्लास के तरीके भी कोलन का उपयोग करते हैं: object:func(args) के बराबर है object.func(object, args).

इसे ध्यान में रखते हुए, यहाँ एक संगत वर्ग है : सिंटैक्टिक चीनी:

<वाक्यविन्यास लैंग = लुआ> स्थानीय वेक्टर = {} वेक्टर.__इंडेक्स = वेक्टर

फ़ंक्शन वेक्टर: नया (x, y, z) - कंस्ट्रक्टर - चूंकि फ़ंक्शन परिभाषा एक कोलन का उपयोग करती है, - इसका पहला तर्क स्वयं है जो संदर्भित करता है - वेक्टर के लिए रिटर्न सेटमेटेबल ({x = x, y = y, z = z}, स्वयं) समाप्त

फ़ंक्शन वेक्टर: परिमाण - एक और तरीका - स्वयं का उपयोग करके अंतर्निहित वस्तु का संदर्भ लें वापसी गणित.sqrt(self.x^2 + self.y^2 + self.z^2) समाप्त

स्थानीय vec = वेक्टर: नया (0, 1, 0) - एक वेक्टर बनाएँ प्रिंट (vec: परिमाण ) - एक विधि कॉल करें (आउटपुट: 1) प्रिंट (vec.x) - एक सदस्य चर तक पहुँचें (आउटपुट: 0) </वाक्यविन्यास हाइलाइट>

वंशानुक्रम
लुआ वर्ग विरासत देने के लिए लुआ मेटाटेबल्स का उपयोग करने का समर्थन करता है। इस उदाहरण में, हम वैक्टर को एक व्युत्पन्न वर्ग में उनके मूल्यों को एक स्थिरांक से गुणा करने की अनुमति देते हैं।

<वाक्यविन्यास लैंग = लुआ> स्थानीय वेक्टर = {} वेक्टर.__इंडेक्स = वेक्टर

फ़ंक्शन वेक्टर: नया (x, y, z) - कंस्ट्रक्टर - यहाँ, स्वयं का तात्पर्य किसी भी वर्ग के नए से है -- विधि जिसे हम कहते हैं। एक व्युत्पन्न वर्ग में, स्व-इच्छा - व्युत्पन्न वर्ग हो; वेक्टर वर्ग में, self - वेक्टर होगा रिटर्न सेटमेटेबल ({x = x, y = y, z = z}, स्वयं) समाप्त

फ़ंक्शन वेक्टर: परिमाण - एक और तरीका - स्वयं का उपयोग करके अंतर्निहित वस्तु का संदर्भ लें वापसी गणित.sqrt(self.x^2 + self.y^2 + self.z^2) समाप्त

- वर्ग विरासत का उदाहरण स्थानीय वेक्टरमुल्ट = {} वेक्टरMult.__index = वेक्टरMult setmetatable(VectorMult, वेक्टर) - वेक्टर के बच्चे को वेक्टर मल्टी बनाएं

फ़ंक्शन वेक्टर मल्टी: गुणा (मान) स्व.एक्स = स्व.एक्स * मूल्य Self.y = Self.y * मान स्व.जेड = स्व.जेड * मूल्य स्वयं लौटें समाप्त

स्थानीय vec = वेक्टरमल्टी: नया (0, 1, 0) - एक वेक्टर बनाएँ प्रिंट (vec: परिमाण ) - एक विधि कॉल करें (आउटपुट: 1) प्रिंट (vec.y) - एक सदस्य चर तक पहुँचें (आउटपुट: 1) vec: गुणा (2) - वेक्टर के सभी घटकों को 2 से गुणा करें प्रिंट (vec.y) - सदस्य को फिर से एक्सेस करें (आउटपुट: 2) </वाक्यविन्यास हाइलाइट>

लुआ एकाधिक वंशानुक्रम का भी समर्थन करता है; __index या तो एक समारोह या एक टेबल हो सकता है। ऑपरेटर ओवरलोडिंग भी की जा सकती है; लुआ मेटाटेबल्स में तत्व हो सकते हैं जैसे __add, __sub, और इसी तरह।

कार्यान्वयन
Lua प्रोग्राम सीधे टेक्स्ट वाली Lua फ़ाइल से भाषा की व्याख्या नहीं करते हैं, लेकिन बायटेकोड में कंपाइलर होते हैं, जो तब Lua आभासी मशीन पर चलाया जाता है। संकलन प्रक्रिया आमतौर पर उपयोगकर्ता के लिए अदृश्य होती है और रन टाइम (प्रोग्राम जीवनचक्र चरण) के दौरान निष्पादित की जाती है। कंपाइलर को छोड़ कर मेजबान पर्यावरण की स्मृति पदचिह्न को कम करें। लुआ बाइटकोड का उपयोग करके लुआ के भीतर से उत्पादन और निष्पादन भी किया जा सकता है  स्ट्रिंग लाइब्रेरी से फ़ंक्शन और   कार्य करता है। लुआ संस्करण 5.3.4 सी कोड की लगभग 24,000 लाइनों में लागू किया गया है।

अधिकांश सीपीयू की तरह, और अधिकांश वर्चुअल मशीनों (जो स्टैक मशीन|स्टैक-आधारित हैं) के विपरीत, लुआ वीएम रजिस्टर मशीन|रजिस्टर-आधारित है, और इसलिए वास्तविक हार्डवेयर डिज़ाइन के अधिक निकट है। रजिस्टर आर्किटेक्चर दोनों मूल्यों की अत्यधिक प्रतिलिपि से बचाता है और प्रति कार्य निर्देशों की कुल संख्या को कम करता है। लुआ 5 की वर्चुअल मशीन व्यापक उपयोग के लिए पहले रजिस्टर-आधारित शुद्ध वीएम में से एक है। तोता आभासी मशीन और Android (ऑपरेटिंग सिस्टम) का Dalvik (सॉफ़्टवेयर) दो अन्य प्रसिद्ध रजिस्टर-आधारित VM हैं। PCScheme का VM भी रजिस्टर-आधारित था। यह उदाहरण फैक्टोरियल फ़ंक्शन परिभाषित #फ़ैक्टोरियल उदाहरण की बायटेकोड सूची है (जैसा कि  5.1 संकलक): समारोह <फैक्टोरियल.लुआ: 1,7> (9 निर्देश, 36 बाइट्स 0x8063c60 पर) 1 परम, 6 स्लॉट, 0 अपवैल्यू, 6 लोकल, 2 स्थिरांक, 0 फ़ंक्शन 1 [2] भार 1 -1; 1 2 [3] लोड 2 -2; 2 3 [3] मूव 3 0 4 [3] भार 4 -1; 1 5 [3] फोरप्रेप 2 1; से 7 6 [4] एमयूएल 1 1 5 7 [3] फोरलूप 2 -2; से 6 8 [6] वापसी 1 2 9 [7] रिटर्न 0 1

सी एपीआई
लुआ को अन्य अनुप्रयोगों में एम्बेड करने का इरादा है, और इस उद्देश्य के लिए सी (प्रोग्रामिंग भाषा) अप्लिकेशन प्रोग्रामिंग अंतरफलक प्रदान करता है। एपीआई को दो भागों में बांटा गया है: लुआ कोर और लुआ सहायक पुस्तकालय। Lua API का डिज़ाइन, Python (प्रोग्रामिंग लैंग्वेज) के API के विपरीत, C कोड में मैन्युअल संदर्भ गिनती की आवश्यकता को समाप्त करता है। एपीआई, भाषा की तरह, न्यूनतर है। उन्नत कार्यक्षमता सहायक पुस्तकालय द्वारा प्रदान की जाती है, जिसमें बड़े पैमाने पर पूर्वप्रक्रमक मैक्रो (कंप्यूटर विज्ञान) होते हैं जो जटिल तालिका संचालन में सहायता करते हैं।

लुआ सी एपीआई स्टैक (डेटा संरचना) आधारित है। लुआ स्टैक से सबसे सरल सी डेटा प्रकारों (पूर्णांक, फ़्लोट्स, आदि) को पुश और पॉप करने के लिए फ़ंक्शन प्रदान करता है, साथ ही स्टैक के माध्यम से तालिकाओं में हेरफेर करने के लिए फ़ंक्शन प्रदान करता है। लुआ स्टैक पारंपरिक स्टैक से कुछ अलग है; स्टैक को सीधे अनुक्रमित किया जा सकता है, उदाहरण के लिए। नकारात्मक सूचकांक स्टैक के शीर्ष से ऑफ़सेट का संकेत देते हैं। उदाहरण के लिए, -1 सबसे ऊपर है (सबसे हाल ही में धक्का दिया गया मूल्य), जबकि सकारात्मक सूचकांक नीचे से ऑफसेट (सबसे पुराना मूल्य) इंगित करते हैं। स्टैक का उपयोग करके सी और लुआ कार्यों के बीच मार्शलिंग (कंप्यूटर विज्ञान) डेटा भी किया जाता है। लुआ फ़ंक्शन को कॉल करने के लिए, तर्कों को स्टैक पर धकेल दिया जाता है, और फिर  वास्तविक फ़ंक्शन को कॉल करने के लिए उपयोग किया जाता है। लुआ से सीधे बुलाए जाने वाले सी फ़ंक्शन को लिखते समय, स्टैक से तर्क पढ़े जाते हैं।

यहाँ C से Lua फ़ंक्शन को कॉल करने का एक उदाहरण दिया गया है:

<वाक्यविन्यास प्रकाश लैंग = सी>
 * 1) शामिल <stdio.h>
 * 2) शामिल <lua.h> // लुआ मुख्य पुस्तकालय (लुआ_*)
 * 3) शामिल <lauxlib.h> // लुआ सहायक पुस्तकालय (luaL_*)

पूर्णांक मुख्य (शून्य) {   // लुआ राज्य बनाएं लुआ_स्टेट * एल = लुआएल_न्यूस्टेट ;

// लोड करें और एक स्ट्रिंग निष्पादित करें if (luaL_dostring(L, function foo (x,y) return x+y end )) { लुआ_क्लोज़ (एल); वापसी -1; }

// ग्लोबल फू का पुश वैल्यू (ऊपर परिभाषित फंक्शन) // ढेर के लिए, पूर्णांक 5 और 3 के बाद lua_getglobal (एल, फू); लुआ_पुशिनटेगर (एल, 5); लुआ_पुशिनटेगर (एल, 3); लुआ_कॉल (एल, 2, 1); // एक फ़ंक्शन को दो तर्कों और एक वापसी मान के साथ कॉल करें प्रिंटफ (परिणाम:% d \ n, lua_tointeger (एल, -1)); // स्टैक टॉप पर आइटम का पूर्णांक मान प्रिंट करें लुआ_पॉप (एल, 1); // स्टैक को मूल स्थिति में लौटाएं लुआ_क्लोज़ (एल); // करीब लुआ राज्य वापसी 0; } </वाक्यविन्यास हाइलाइट>

इस उदाहरण को चलाना देता है: $ cc -o उदाहरण example.c -llua $ ./उदाहरण परिणाम: 8 </पूर्व>

सी एपीआई लुआ स्टैक में विभिन्न छद्म-सूचकांकों पर स्थित कुछ विशेष टेबल भी प्रदान करता है। पर  लुआ 5.2 से पहले ग्लोबल्स टेबल है,   लुआ के भीतर से, जो मुख्य नामस्थान है। पर स्थित एक रजिस्ट्री भी है   जहां C प्रोग्राम बाद में पुनर्प्राप्ति के लिए Lua मान संग्रहीत कर सकते हैं।

Lua API का उपयोग करके एक्सटेंशन मॉड्यूल लिखना संभव है। एक्सटेंशन मॉड्यूल लाइब्रेरी (कंप्यूटिंग) # डायनेमिक लिंकिंग हैं जिनका उपयोग लुआ लिपियों को मूल सुविधाएं प्रदान करके दुभाषिया की कार्यक्षमता बढ़ाने के लिए किया जा सकता है। लुआ स्क्रिप्ट एक्सटेंशन मॉड्यूल का उपयोग करके लोड कर सकती हैं, लुआ में ही लिखे गए मॉड्यूल की तरह, या साथ. जब सी लाइब्रेरी के माध्यम से लोड किया जाता है  लुआ समारोह की तलाश करेंगे   और इसे कॉल करें, जो लुआ से कॉल करने योग्य किसी भी सी फ़ंक्शन के रूप में कार्य करता है और आम तौर पर विधियों से भरी तालिका देता है। चट्टानों के रूप में जाने जाने वाले मॉड्यूल का बढ़ता हुआ संग्रह LuaRocks नामक पैकेज प्रबंधन प्रणाली के माध्यम से उपलब्ध है, सीपीएएन, RubyGems और पायथन अंडे की भावना में। अन्य स्क्रिप्टिंग भाषाओं सहित अधिकांश लोकप्रिय प्रोग्रामिंग भाषाओं के लिए पूर्व लिखित लुआ भाषा बंधन मौजूद है। सी ++ के लिए, कई टेम्पलेट-आधारित दृष्टिकोण और कुछ स्वचालित बाध्यकारी जेनरेटर हैं।

अनुप्रयोग
वीडियो गेम के विकास में, वीडियो गेम प्रोग्रामर # स्क्रिप्टर द्वारा लुआ को व्यापक रूप से एक स्क्रिप्टिंग भाषा के रूप में उपयोग किया जाता है, मुख्य रूप से एम्बेड करने की कथित सहजता, तेजी से निष्पादन और लघु सीखने की अवस्था के कारण। लुआ का उपयोग करने वाले उल्लेखनीय खेलों में शामिल हैं रोबोक्स, गैरी का मॉड, वारक्राफ्ट की दुनिया, Payday 2, फैंटसी स्टार ऑनलाइन 2, Dota 2, एंग्री बर्ड्स स्पेस, क्राइसिस (वीडियो गेम), गंभीर प्रयास। कुछ गेम जो मूल रूप से लुआ प्रोग्रामिंग या स्क्रिप्टिंग का समर्थन नहीं करते हैं, इस कार्यक्षमता को मॉड्स द्वारा जोड़ा जाता है, जैसे कि कंप्यूटरक्राफ्ट Minecraft के लिए करता है। इसके अलावा, Lua का उपयोग गैर-वीडियो गेम सॉफ़्टवेयर में भी किया जाता है, जैसे कि Adobe Lightroom, Moho (सॉफ़्टवेयर), iClone, Aerospike (डेटाबेस) और FreeBSD और NetBSD में कुछ सिस्टम सॉफ़्टवेयर, और MediaWiki पर टेम्पलेट स्क्रिप्टिंग भाषा के रूप में उपयोग किया जाता है। स्क्रिबंटो एक्सटेंशन। 2003 में, GameDev.net द्वारा किए गए एक सर्वेक्षण से पता चला कि लुआ गेम प्रोग्रामिंग के लिए सबसे लोकप्रिय स्क्रिप्टिंग भाषा थी। 12 जनवरी 2012 को, लुआ को प्रोग्रामिंग टूल्स श्रेणी में पत्रिका गेम डेवलपर (पत्रिका) से फ्रंट लाइन अवॉर्ड 2011 के विजेता के रूप में घोषित किया गया था। बड़ी संख्या में गैर-गेम एप्लिकेशन भी एक्स्टेंसिबिलिटी के लिए लुआ का उपयोग करते हैं, जैसे कि लुआटेक्स, टीएक्स टाइप-सेटिंग भाषा का कार्यान्वयन, रेडिस, एक की-वैल्यू डेटाबेस, नव के, एक टेक्स्ट एडिटर, नगनेक्स, एक वेब सर्वर और वायरशार्क, एक नेटवर्क पैकेट विश्लेषक।

Scribunto एक्सटेंशन के माध्यम से, Lua MediaWiki सॉफ़्टवेयर में सर्वर-साइड स्क्रिप्टिंग भाषा के रूप में उपलब्ध है जो विकिपीडिया और अन्य विकी को शक्ति प्रदान करता है। इसके उपयोगों में विकिडेटा से लेखों में डेटा के एकीकरण की अनुमति देना शामिल है, और शक्ति देना.

लुआ
को संकलित करने वाली भाषाएं
 * मूनस्क्रिप्ट एक गतिशील प्रोग्रामिंग भाषा है, कॉफीस्क्रिप्ट से प्रेरित व्हॉट्सएप चरित्र-संवेदनशील स्क्रिप्टिंग भाषा है, जिसे लुआ में संकलित किया गया है। इसका मतलब है कि उपयोग करने के बजाय  तथा   (या   तथा  ) कोड के अनुभागों को परिसीमित करने के लिए यह लाइन ब्रेक (कंप्यूटिंग) और इंडेंटेशन शैली का उपयोग करता है।  मूनस्क्रिप्ट का एक उल्लेखनीय उपयोग एक वीडियो गेम वितरण वेबसाइट Itch.io है।
 * Haxe Lua लक्ष्य के संकलन का समर्थन करता है, Lua 5.1-5.3 के साथ-साथ LuaJIT 2.0 और 2.1 का समर्थन करता है।
 * फेनेल, एक लिस्प बोली जो लुआ को लक्षित करती है। * अर्न, एक लिस्प (प्रोग्रामिंग भाषा) बोली जो लुआ पर बनी है।
 * एमुलेट, एक एमएल (प्रोग्रामिंग भाषा) जैसी फंक्शनल प्रोग्रामिंग, जिसका कंपाइलर लुआ फाइलों को आउटपुट करता है।

बोलियां
इसके अलावा, लुआ उपयोगकर्ता समुदाय संदर्भ सी कार्यान्वयन के शीर्ष पर कुछ पावर पैच प्रदान करता है।
 * लुजिट
 * Roblox से Luau, धीरे-धीरे टाइपिंग और एर्गोनोमिक परिवर्धन के साथ Lua 5.1 भाषा।
 * वैकल्पिक स्थिर टाइपिंग के साथ रवि, JIT-सक्षम Lua 5.3 भाषा। जेआईटी प्रकार की जानकारी द्वारा निर्देशित है।
 * शाइन, लुआजिट का एक फोर्क जिसमें मॉड्यूल सिस्टम और मैक्रो सिस्टम समेत कई एक्सटेंशन हैं।

यह भी देखें

 * प्रोग्रामिंग भाषाओं की तुलना

अग्रिम पठन

 * (The 1st ed. is available online.)


 * Chapters 6 and 7 are dedicated to Lua, while others look at software in Brazil more broadly.
 * Interview with Roberto Ierusalimschy.
 * How the embeddability of Lua impacted its design.
 * Lua papers and theses
 * Chapters 6 and 7 are dedicated to Lua, while others look at software in Brazil more broadly.
 * Interview with Roberto Ierusalimschy.
 * How the embeddability of Lua impacted its design.
 * Lua papers and theses
 * Interview with Roberto Ierusalimschy.
 * How the embeddability of Lua impacted its design.
 * Lua papers and theses
 * How the embeddability of Lua impacted its design.
 * Lua papers and theses
 * Lua papers and theses

इस पेज में लापता आंतरिक लिंक की सूची

 * सीएलयू (प्रोग्रामिंग भाषा)
 * उच्च स्तरीय प्रोग्रामिंग भाषा
 * भाषा का अंकन
 * दुभाषिया (कंप्यूटिंग)
 * ट्रेड बैरियर
 * रियो डी जनेरियो के पोंटिफिकल कैथोलिक विश्वविद्यालय
 * संदर्भ द्वारा कॉल करें
 * साहचर्य सरणी
 * अनाम समारोह
 * वर्ग (कंप्यूटर प्रोग्रामिंग)
 * जानकारी छुपाना
 * प्रथम श्रेणी समारोह
 * नाम स्थान
 * कम से कम विशेषाधिकार का सिद्धांत
 * रूपांतरण टाइप करें
 * क्लोजर (कंप्यूटर साइंस)
 * गतिशील रूप से टाइप किया गया
 * coroutine
 * सरणी डेटा संरचना
 * हैश टेबल
 * शेयर करके कॉल करें
 * स्वयं (प्रोग्रामिंग भाषा)
 * फैक्टरी विधि पैटर्न
 * विधि (कंप्यूटर विज्ञान)
 * समय-समय पर संकलन
 * रन टाइम (कार्यक्रम जीवनचक्र चरण)
 * व्याख्या की गई भाषा
 * दैविक (सॉफ्टवेयर)
 * पायथन (प्रोग्रामिंग भाषा)
 * ढेर (डेटा संरचना)
 * अजगर के अंडे
 * वीडियो गेम विकास
 * एयरोस्पाइक (डेटाबेस)
 * मोहो (सॉफ्टवेयर)
 * nginx
 * लुआटेक्स
 * विकिडाटा
 * व्हाइटस्पेस चरित्र
 * क्रमिक टाइपिंग

बाहरी संबंध

 * Lua Users, Community
 * Lua Forum
 * LuaDist
 * Lua Rocks - Package manager
 * Projects in Lua
 * Projects in Lua