ลัว
ภาพหน้าจอโค้ด Lua จากโมดูล Lua ของ Wikipediaโดยใช้ส่วนขยายMediaWiki Scribunto
กระบวนทัศน์	หลายกระบวนทัศน์ : การเขียนสคริปต์ , เชิงคำสั่ง ( เชิงกระบวนการ , อิงตามต้นแบบ , เชิงวัตถุ ), เชิงฟังก์ชัน , เมตา , เชิงสะท้อน
ออกแบบโดย	โรแบร์โต อิเอรูซาลิมชี่วัลเดมาร์ เซเลส ลุยซ์เฮนริเก้ เดอ ฟิเกเรโด
ปรากฏครั้งแรก	พ.ศ. 2536 ( 1993 )
เวอร์ชันเสถียร	5.5 [ 1 ]  / 22 ธันวาคม 2025 ( 22 ธันวาคม 2025 )
วินัยในการพิมพ์	ไดนามิกแข็งแกร่งเป็ด​​
ภาษาการใช้งาน	ANSI C
โอเอส	ข้ามแพลตฟอร์ม
ใบอนุญาต	เอ็มไอที
นามสกุลไฟล์	.lua
เว็บไซต์	lua .org
การนำไปใช้งานหลักๆ
Lua , LuaJIT , LuaVela , MoonSharp ,
ภาษาถิ่น
GSL Shell , Luau
ได้รับอิทธิพลจาก
C++ , CLU , Scheme , SNOBOL
ได้รับอิทธิพล
GameMonkey , Io , Julia , Red , Ruby , Squirrel , Luau

Lua ( / ˈ l uː . ə / , LOO -ə ; จากภาษาโปรตุเกส : lua [ˈlu(w)ɐ]แปลว่าดวงจันทร์ )เป็นภาษาโปรแกรมระดับสูงที่มีน้ำหนักเบาและรองรับหลายกระบวนทัศน์ออกแบบมาเพื่อใช้งานฝังตัวในแอปพลิ เคชันเป็นหลัก ^{[ 2 ]} Lua เป็นซอฟต์แวร์ข้ามแพลตฟอร์มเนื่องจากตัวแปลรหัสไบต์ที่คอมไพล์ แล้ว เขียนด้วยภาษาANSI C [ ^{3 ] และ} Lua มีอินเทอร์เฟซการเขียนโปรแกรมแอปพลิเคชัน ( API ) ภาษา C ที่ค่อนข้างง่ายสำหรับการฝังลงในแอปพลิเคชัน^{[ 4 ]}

ภาษา Lua ถือกำเนิดขึ้นในปี 1993 ในฐานะภาษาสำหรับขยายแอปพลิเคชันซอฟต์แวร์เพื่อตอบสนองความต้องการในการปรับแต่งที่เพิ่มขึ้นในขณะนั้น มันมีฟังก์ชันพื้นฐานของ ภาษา การเขียนโปรแกรมเชิง ขั้นตอน ส่วนใหญ่ แต่ไม่ได้รวมคุณสมบัติที่ซับซ้อนกว่าหรือเฉพาะด้านไว้แต่กลับมีกลไกสำหรับการขยายภาษา ทำให้นักโปรแกรมสามารถนำคุณสมบัติเหล่านั้นมาใช้ได้ เนื่องจาก Lua ถูกออกแบบมาให้เป็นภาษาสำหรับการขยายแบบฝังตัวทั่วไป นักออกแบบของ Lua จึงมุ่งเน้นไปที่การปรับปรุงความเร็ว ความสามารถ ในการพกพา ความสามารถในการขยาย และความง่ายในการใช้งานในการพัฒนา

ภาษา โปรแกรม Lua ถูกสร้างขึ้นในปี 1993 โดยRoberto Ierusalimschy , Luiz Henrique de Figueiredo และ Waldemar Celes สมาชิกของกลุ่มเทคโนโลยีคอมพิวเตอร์กราฟิก ( Tecgraf ) ที่มหาวิทยาลัยคาทอลิกแห่งริโอเดจาเนโรประเทศบราซิล

ตั้งแต่ปี 1977 จนถึงปี 1992 บราซิลมีนโยบายกีดขวางทางการค้า อย่างเข้มงวด (เรียกว่าตลาดสำรอง) สำหรับ ฮาร์ดแวร์ และซอฟต์แวร์คอมพิวเตอร์โดยเชื่อว่าบราซิลสามารถและควรผลิตฮาร์ดแวร์และซอฟต์แวร์ของตนเองได้ ในสภาพแวดล้อมเช่นนั้น ลูกค้าของ Tecgraf ไม่สามารถซื้อซอฟต์แวร์ที่ปรับแต่งเองจากต่างประเทศได้ ไม่ว่าจะด้วยเหตุผลทางการเมืองหรือทางการเงิน ภายใต้ตลาดสำรอง ลูกค้าจะต้องผ่านกระบวนการทางราชการที่ซับซ้อนเพื่อพิสูจน์ว่าความต้องการของพวกเขาไม่สามารถตอบสนองได้โดยบริษัทของบราซิล ด้วยเหตุผลเหล่านี้ทำให้ Tecgraf ต้องนำเครื่องมือพื้นฐานที่ต้องการมาใช้ตั้งแต่เริ่มต้น^{[ 5 ]}

ภาษาต้นแบบของ Lua คือภาษาสำหรับการอธิบายข้อมูลและการกำหนดค่า Simple Object Language (SOL) และ Data-Entry Language (DEL) ^{[ 6 ]} ภาษา เหล่านี้ได้รับการพัฒนาขึ้นอย่างอิสระที่ Tecgraf ในปี 1992–1993 เพื่อเพิ่มความยืดหยุ่นให้กับสองโครงการที่แตกต่างกัน (ทั้งสองเป็นโปรแกรมกราฟิกแบบโต้ตอบสำหรับการใช้งานทางวิศวกรรมที่ บริษัท Petrobras ) SOL และ DEL ขาดโครงสร้างการควบคุมการไหล และ Petrobras รู้สึกถึงความต้องการที่เพิ่มขึ้นในการเพิ่มพลังการเขียนโปรแกรมอย่างเต็มรูปแบบให้กับภาษาเหล่านี้

ในหนังสือ The Evolution of Luaผู้เขียนภาษาได้เขียนไว้ว่า: ^{[ 5 ]}

ในปี 1993 คู่แข่งที่แท้จริงเพียงรายเดียวคือTclซึ่งได้รับการออกแบบมาโดยเฉพาะเพื่อฝังลงในแอปพลิเคชัน อย่างไรก็ตาม Tcl มีไวยากรณ์ที่ไม่คุ้นเคย ไม่ให้การสนับสนุนที่ดีสำหรับการอธิบายข้อมูล และทำงานได้เฉพาะบนแพลตฟอร์ม Unix เท่านั้น เราไม่ได้พิจารณาLISPหรือSchemeเนื่องจากไวยากรณ์ที่ไม่เป็นมิตรPythonยังอยู่ในช่วงเริ่มต้น ในบรรยากาศแบบเสรีและทำเองได้ที่ครอบงำ Tecgraf ในขณะนั้น จึงเป็นเรื่องธรรมชาติที่เราจะพยายามพัฒนาภาษาสคริปต์ของเราเอง... เนื่องจากผู้ใช้ภาษาจำนวนมากไม่ใช่โปรแกรมเมอร์มืออาชีพ ภาษาจึงควรหลีกเลี่ยงไวยากรณ์และความหมายที่เข้าใจยาก การใช้งานภาษาใหม่ควรพกพาได้สูง เนื่องจากลูกค้าของ Tecgraf มีแพลตฟอร์มคอมพิวเตอร์ที่หลากหลายมาก สุดท้าย เนื่องจากเราคาดว่าผลิตภัณฑ์อื่นๆ ของ Tecgraf ก็จำเป็นต้องมีภาษาสคริปต์ฝังอยู่ด้วย ภาษาใหม่จึงควรทำตามแบบอย่างของ SOL และจัดให้เป็นไลบรารีที่มี API ภาษา C

Lua 1.0 ได้รับการออกแบบในลักษณะที่ว่าตัวสร้างวัตถุของมัน ซึ่งในขณะนั้นแตกต่างจากรูปแบบที่เบาและยืดหยุ่นในปัจจุบันเล็กน้อย ได้รวมเอาไวยากรณ์การอธิบายข้อมูลของ SOL เข้าไว้ด้วย (จึงเป็นที่มาของชื่อ Lua: Solหมายถึง "ดวงอาทิตย์" ในภาษาโปรตุเกส และLua หมายถึง "ดวงจันทร์") ไวยากรณ์ ของ Lua สำหรับโครงสร้างควบคุมส่วนใหญ่ยืมมาจากModula ( if, while, repeat/ until) แต่ยังได้รับอิทธิพลจากCLU (การกำหนดค่าหลายรายการและการส่งคืนค่าหลายรายการจากการเรียกฟังก์ชัน ซึ่งเป็นทางเลือกที่ง่ายกว่าพารามิเตอร์อ้างอิงหรือตัวชี้ แบบชัดเจน ) C++ ("แนวคิดที่ยอดเยี่ยมในการอนุญาตให้ประกาศตัวแปรโลคอล เฉพาะที่ที่เราต้องการ" ^{[ 5 ]} ) SNOBOLและAWK ( อาร์เรย์แบบเชื่อมโยง ) ในบทความที่ตีพิมพ์ในDr. Dobb's Journalผู้สร้าง Lua ยังระบุด้วยว่า LISP และ Scheme ด้วยกลไกโครงสร้างข้อมูลเดียวที่แพร่หลาย ( รายการ ) มีอิทธิพลอย่างมากต่อการตัดสินใจของพวกเขาในการพัฒนาตารางเป็นโครงสร้างข้อมูลหลักของ Lua ^{[ 7 ]}

ความหมายของ Lua ได้รับอิทธิพลจาก Scheme มากขึ้นเรื่อยๆ เมื่อเวลาผ่านไป^{[ 5 ]}โดยเฉพาะอย่างยิ่งกับการแนะนำฟังก์ชันนิรนามและขอบเขตคำศัพท์แบบเต็มรูปแบบมีการเพิ่มคุณสมบัติหลายอย่างใน Lua เวอร์ชันใหม่

Lua เวอร์ชันก่อน 5.0 เผยแพร่ภายใต้ใบอนุญาตที่คล้ายกับใบอนุญาต BSDตั้งแต่เวอร์ชัน 5.0 เป็นต้นไป Lua ได้รับอนุญาตภายใต้ใบอนุญาต MITทั้งสองเป็นใบอนุญาตซอฟต์แวร์เสรีแบบเปิดกว้างและแทบจะเหมือนกันทุกประการ

Lua มักถูกอธิบายว่าเป็นภาษา " หลายกระบวนทัศน์ " โดยมีชุดคุณสมบัติทั่วไปจำนวนเล็กน้อยที่สามารถขยายให้เหมาะสมกับปัญหาประเภทต่างๆ ได้ Lua ไม่รองรับการสืบทอด โดยตรง แต่ยอมให้ใช้งานได้โดยใช้เมตาเทเบิลในทำนองเดียวกัน Lua อนุญาตให้นักเขียนโปรแกรมใช้งานเนมสเปซคลาสและคุณสมบัติอื่นๆ ที่เกี่ยวข้องโดยใช้การใช้งานตารางเดียวฟังก์ชันระดับเฟิร์สคลาสช่วยให้สามารถใช้เทคนิคต่างๆ จากการเขียนโปรแกรมเชิงฟังก์ชันได้และขอบเขตเชิงคำศัพท์ แบบเต็มรูปแบบช่วยให้ สามารถซ่อนข้อมูลได้อย่างละเอียดเพื่อบังคับใช้หลักการของสิทธิ์ขั้นต่ำสุด

โดยทั่วไป Lua มุ่งมั่นที่จะมอบเมตาฟีเจอร์ ที่เรียบง่ายและยืดหยุ่น ซึ่งสามารถขยายได้ตามต้องการ แทนที่จะมอบชุดฟีเจอร์เฉพาะสำหรับกระบวนทัศน์การเขียนโปรแกรมแบบใดแบบหนึ่ง ส่งผลให้ภาษาพื้นฐานมีน้ำหนักเบาตัวแปลอ้างอิงฉบับเต็มมีขนาดเพียงประมาณ 293  kBเมื่อคอมไพล์แล้ว^{[ 3 ]}และสามารถปรับให้เข้ากับแอปพลิเคชันที่หลากหลายได้อย่างง่ายดาย

Lua เป็น ภาษา ที่มีการกำหนดประเภทข้อมูลแบบไดนามิกซึ่งออกแบบมาเพื่อใช้เป็นภาษาส่วนขยายหรือภาษาสคริปต์ จึงมีขนาดกะทัดรัดพอที่จะใช้งานได้บนแพลตฟอร์มโฮสต์ที่หลากหลาย รองรับเฉพาะโครงสร้างข้อมูลพื้นฐานจำนวนเล็กน้อย เช่น ค่า บูลีนตัวเลข ( เลข ทศนิยมสองเท่า และจำนวนเต็ม64 บิต ตามค่าเริ่มต้น) และสตริงโครงสร้างข้อมูลทั่วไป เช่นอาร์เรย์เซตรายการและเรคอร์ดสามารถแสดงได้โดยใช้โครงสร้างข้อมูลพื้นฐานเพียงอย่างเดียวของ Lua คือ ตาราง ซึ่งโดยพื้นฐานแล้วเป็นอาร์เรย์แบบเชื่อมโยงที่ ไม่ เป็นเนื้อเดียวกัน

Lua มีฟีเจอร์ขั้นสูงอยู่ไม่กี่อย่าง เช่นฟังก์ชันระดับเฟิร์สคลาส การจัดการหน่วยความ จำอัตโนมัติ ( garbage collection ) โคลเชอร์ ( closures ) การเรียก ฟังก์ชันแบบ tail callที่เหมาะสม การแปลงค่า (การแปลงอัตโนมัติระหว่างสตริงและตัวเลขในขณะรันไทม์) โครูทีน (การทำงานหลายอย่างพร้อมกันแบบร่วมมือ) และการโหลดโมดูลแบบไดนามิก

โปรแกรม "Hello, World!"แบบคลาสสิกสามารถเขียนได้ดังนี้ โดยมีหรือไม่มีวงเล็บ: ^{[ 8 ] [ a ]}

พิมพ์( "สวัสดีโลก!" )

พิมพ์"สวัสดีโลก!"

การประกาศตัวแปรโดยไม่กำหนดค่า

ตัวแปรท้องถิ่น

การประกาศตัวแปรที่มีค่าเป็น 1000 (หนึ่งพัน)

นักเรียนท้องถิ่น= 1,000 คน

ในภาษา Lua การใส่คำอธิบายจะเริ่มต้นด้วยเครื่องหมายยัติภังค์สองตัวและยาวไปจนถึงท้ายบรรทัด คล้ายกับภาษาAda , Eiffel , Haskell , SQLและVHDLส่วนข้อความและคำอธิบายที่ยาวหลายบรรทัดจะใช้เครื่องหมายวงเล็บเหลี่ยมสองตัวกำกับ

-- ข้อความแสดงความคิดเห็นบรรทัดเดียว--[[ ข้อความแสดงความคิดเห็นหลายบรรทัด--]]

ตัวอย่างนี้แสดงการใช้งานฟังก์ชัน แฟกทอเรียล :

ฟังก์ชันแฟกทอเรียล( n ) โลคอลx = 1 สำหรับi = 2 , n ทำซ้ำx = x * i สิ้นสุดส่งคืนx สิ้นสุด

ภาษา Lua มีการทดสอบแบบมีเงื่อนไขอยู่if then end ประเภทเดียว คือ การทดสอบ โดยใช้โครงสร้าง ตัวเลือก elseและ การควบคุมการทำงานelseif then

คำสั่ง ทั่วไปนี้if then endต้องการคำหลักทั้งสามคำ:

ถ้าเงื่อนไขเป็นจริง-- สิ้นสุด ส่วนเนื้อหาของคำสั่ง

ตัวอย่างของifข้อความ

ถ้าx ≠ 10 แล้วให้พิมพ์( x )

elseสามารถเพิ่มคำหลักพร้อมกับบล็อกคำสั่งประกอบเพื่อควบคุมการทำงานเมื่อเงื่อนไขifประเมินค่าเป็นจริงfalse:

ถ้าเงื่อนไขเป็นจริง-- ส่วนเนื้อหาของคำสั่งมิฉะนั้น-- ส่วน เนื้อหาของคำสั่ง

ตัวอย่างของif elseข้อความ

ถ้าx == 10 แล้วให้พิมพ์( 10 ) มิฉะนั้นให้พิมพ์( x )

นอกจากนี้ ยังสามารถควบคุมการทำงานได้ตามเงื่อนไขหลายประการโดยใช้elseif thenคำหลักดังต่อไปนี้:

ถ้าเงื่อนไขเป็นจริง-- ส่วนเนื้อหาของคำสั่งมิฉะนั้นถ้าเงื่อนไข เป็นจริง -- ส่วนเนื้อหาของคำสั่งมิฉะนั้น-- ตัวเลือก-- ตัวเลือก ส่วนเนื้อหาของคำสั่งเริ่มต้น

ตัวอย่างของif elseif elseข้อความ

ถ้าx == y แล้วให้พิมพ์( "x = y" ) มิฉะนั้นถ้าx == z แล้วให้พิมพ์( "x = z" ) มิฉะนั้น-- ตัวเลือกเสริม ให้พิมพ์( "x ไม่เท่ากับตัวแปรอื่นใด" )

ภาษา Lua มีลูปแบบมีเงื่อนไขอยู่สี่ประเภท ได้แก่whileลูป `initial` , repeatลูป `initial` (คล้ายกับdo whileลูป `initial` ), forลูป ตัวเลข และforลูป ทั่วไป

--เงื่อนไข = จริงในขณะที่เงื่อนไขดำเนินไป--คำสั่งสิ้นสุดทำซ้ำคำสั่งจนกว่าจะ ตรงตาม เงื่อนไขfor i = first , last , delta do --delta อาจเป็นค่าลบได้ ทำให้ลูป for สามารถนับถอยหลังหรือนับขึ้นได้--คำสั่ง--ตัวอย่าง: print(i) end

ลูป ทั่วไปนี้forจะวนซ้ำในตาราง_Gโดยใช้ฟังก์ชันตัววนซ้ำมาตรฐานpairsจนกว่าจะส่งค่ากลับเป็นnil:

สำหรับคู่คีย์และค่า( _G ) ให้พิมพ์คีย์และค่าออกมา​​

ลูปสามารถซ้อนกันได้ (ใส่ไว้ในลูปอื่น)

ตารางพิกัดท้องถิ่น= { { 11 , 12 , 13 }, { 21 , 22 , 23 }, { 31 , 32 , 33 } }สำหรับy และrow เป็นคู่ๆ( grid ) ทำซ้ำสำหรับx และvalue เป็นคู่ๆ( row ) ทำซ้ำ พิมพ์( x , y , value ) จบ

ตัวอย่างต่อไปนี้แสดงให้เห็นถึง การที่ Lua ปฏิบัติต่อฟังก์ชันในฐานะ ค่า ระดับแรกโดยมีการปรับเปลี่ยนพฤติกรรมของฟังก์ชัน print:

do local oldprint = print -- เก็บฟังก์ชัน print ปัจจุบันไว้ใน oldprint function print ( s ) --[[ กำหนดฟังก์ชัน print ใหม่ ฟังก์ชัน print ปกติยังคงสามารถใช้งานได้ ผ่าน oldprint ฟังก์ชันใหม่มีอาร์กิวเมนต์เพียงตัวเดียว]] oldprint ( s == "foo" and "bar" or s ) end end

การเรียกใช้ฟังก์ชันดังกล่าวในอนาคตprintจะถูกส่งผ่านฟังก์ชันใหม่ และเนื่องจากขอบเขตการเข้าถึงตามคำศัพท์ ของ Lua ฟังก์ชัน print เดิมจะสามารถเข้าถึงได้โดยฟังก์ชัน print ใหม่ที่ได้รับการแก้ไขแล้วเท่านั้น

นอกจากนี้ Lua ยังรองรับการปิดล้อม (closures)ดังแสดงในตัวอย่างด้านล่าง:

ฟังก์ชันaddto ( x ) -- ส่งคืนฟังก์ชันใหม่ที่เพิ่ม x เข้ากับอาร์กิวเมนต์ฟังก์ชันส่งคืน( y ) --[[ เมื่อเราอ้างถึงตัวแปร x ซึ่งอยู่นอก ขอบเขตปัจจุบันและมีอายุการใช้งานสั้นกว่า ฟังก์ชันนิรนามนี้ Lua จะสร้าง closure ขึ้นมา]] ส่งคืนx + y end end fourplus = addto ( 4 ) print ( fourplus ( 3 )) -- พิมพ์ 7--นอกจากนี้ยังสามารถทำได้โดยการเรียกฟังก์ชันด้วยวิธีต่อไปนี้: print ( addto ( 4 )( 3 )) --[[ เนื่องจากเราเรียกฟังก์ชันที่ส่งคืนจาก 'addto(4)' ด้วยอาร์กิวเมนต์ '3' โดยตรง ซึ่งจะช่วยลดต้นทุนข้อมูลและเพิ่มประสิทธิภาพหากเรียกใช้ซ้ำๆ]]

xทุกครั้งที่มีการเรียกใช้ฟังก์ชัน จะมีการสร้างClosure ใหม่สำหรับตัวแปรนั้นaddtoเพื่อให้ฟังก์ชันนิรนามใหม่แต่ละฟังก์ชันที่ส่งคืนมาสามารถเข้าถึงxพารามิเตอร์ของตัวเองได้เสมอ Closure นี้จะถูกจัดการโดย Garbage Collector ของ Lua เช่นเดียวกับอ็อบเจ็กต์อื่นๆ

ตารางเป็นโครงสร้างข้อมูลที่สำคัญที่สุด (และโดยการออกแบบแล้ว เป็นชนิดข้อมูลผสมแบบ พื้นฐานเพียงชนิดเดียว ) ในภาษา Lua และเป็นรากฐานของชนิดข้อมูลทั้งหมดที่ผู้ใช้สร้างขึ้น ตารางคืออาร์เรย์แบบเชื่อมโยงที่มีการเพิ่มคีย์ตัวเลขอัตโนมัติและไวยากรณ์พิเศษ

ตารางคือชุดของคู่คีย์และข้อมูล โดยที่ข้อมูลจะถูกอ้างอิงด้วยคีย์ กล่าวอีกนัยหนึ่งคือ เป็นอาร์เรย์แบบเชื่อมโยงที่ไม่เหมือนกัน ซึ่งถูกแฮชไว้

ตารางถูกสร้างขึ้นโดยใช้{}ไวยากรณ์ตัวสร้าง

a_table = {} -- สร้างตารางใหม่ที่ว่างเปล่า

ตารางจะถูกส่งผ่านโดยการอ้างอิงเสมอ (ดูการเรียกใช้โดยการแชร์ )

คีย์ (ดัชนี) สามารถมีค่าใดก็ได้ ยกเว้นnilค่าNaNรวมถึงฟังก์ชันด้วย

a_table = { x = 10 } -- สร้างตารางใหม่ โดยมีรายการหนึ่งรายการที่แมป "x" กับตัวเลข 10 print ( a_table [ "x" ]) -- พิมพ์ค่าที่เชื่อมโยงกับคีย์สตริง ในกรณีนี้คือ 10 b_table = a_table b_table [ "x" ] = 20 -- ค่าในตารางถูกเปลี่ยนเป็น 20 print ( b_table [ "x" ]) -- พิมพ์ 20 print ( a_table [ "x" ]) -- พิมพ์ 20 เช่นกัน เพราะ a_table และ b_table ต่างก็อ้างอิงถึงตารางเดียวกัน

ตารางมักใช้เป็นโครงสร้าง (หรือบันทึก ) โดยใช้สตริงเป็นคีย์ เนื่องจากการใช้งานแบบนี้เป็นเรื่องปกติมาก Lua จึงมีไวยากรณ์พิเศษสำหรับการเข้าถึงฟิลด์ดังกล่าว^{[ 10 ]}

point = { x = 10 , y = 20 } -- สร้างตารางใหม่print ( point [ "x" ]) -- พิมพ์ 10 print ( point . x ) -- มีความหมายเหมือนกับบรรทัดด้านบนทุกประการ การใช้สัญลักษณ์จุดเพื่อความสะดวกในการอ่านเป็นเพียงรูปแบบการเขียนเท่านั้น

การใช้ตารางเพื่อจัดเก็บฟังก์ชันที่เกี่ยวข้อง สามารถทำหน้าที่เสมือนเป็นเนมสเปซได้

จุด= {}Point.new = function ( x , y ) return { x = x , y = y } -- return {["x"] = x, ["y"] = y } endPoint.set_x = function ( point , x ) point.x = x -- point [ " x" ] = x ; end

ตารางจะได้รับการกำหนดคีย์ตัวเลขโดยอัตโนมัติ ทำให้สามารถใช้งานเป็นชนิดข้อมูลอาร์เรย์ได้ ดัชนีอัตโนมัติแรกคือ 1 แทนที่จะเป็น 0 เหมือนในภาษาโปรแกรมอื่นๆ (แม้ว่าจะอนุญาตให้กำหนดดัชนีเป็น 0 ได้อย่างชัดเจนก็ตาม)

คีย์ตัวเลข1แตกต่างจากคีย์"1"ข้อความ

array = { "a" , "b" , "c" , "d" } -- ดัชนีจะถูกกำหนดโดยอัตโนมัติprint ( array [ 2 ]) -- พิมพ์ "b" การกำหนดดัชนีอัตโนมัติใน Lua เริ่มต้นที่ 1 print ( # array ) -- พิมพ์ 4 # คือตัวดำเนินการความยาวสำหรับตารางและสตริงarray [ 0 ] = "z" -- ศูนย์เป็นดัชนีที่ถูกต้องprint ( # array ) -- ยังคงพิมพ์ 4 เนื่องจากอาร์เรย์ใน Lua เริ่มต้นที่ 1

ความยาวของตารางtถูกกำหนดให้เป็นดัชนีจำนวนเต็มใดๆnที่t[n]ไม่ใช่nilและt[n+1]คือnil; ยิ่งไปกว่านั้น ถ้าคือt[1]อาจเป็นศูนย์ สำหรับอาร์เรย์ปกติที่มีค่าที่ไม่ใช่ศูนย์ตั้งแต่ 1 ถึงค่าที่กำหนดความยาวของมันคือดัชนีของค่าสุดท้าย หากอาร์เรย์มี "ช่องว่าง" (นั่นคือ ค่าศูนย์ระหว่างค่าที่ไม่ใช่ศูนย์อื่นๆ) แล้วอาจเป็นดัชนีใดๆ ที่อยู่ก่อนหน้าค่าโดยตรง (นั่นคือ อาจพิจารณาค่าศูนย์ใดๆ ดังกล่าวเป็นจุดสิ้นสุดของอาร์เรย์) ^{[ 11 ]}nilnnn#tnil

ExampleTable = { { 1 , 2 , 3 , 4 }, { 5 , 6 , 7 , 8 } } print ( ExampleTable [ 1 ][ 3 ]) -- พิมพ์ "3" print ( ExampleTable [ 2 ][ 4 ]) -- พิมพ์ "8"

ตารางสามารถเป็นอาร์เรย์ของอ็อบเจ็กต์ได้

ฟังก์ชันPoint ( x , y ) -- ตัวสร้างอ็อบเจ็กต์ "Point" return { x = x , y = y } -- สร้างและส่งคืนอ็อบเจ็กต์ใหม่ (ตาราง) end array = { Point ( 10 , 20 ), Point ( 30 , 40 ), Point ( 50 , 60 ) } -- สร้างอาร์เรย์ของจุด-- array = { { x = 10, y = 20 }, { x = 30, y = 40 }, { x = 50, y = 60 } }; print ( array [ 2 ]. y ) -- พิมพ์ 40

การใช้แผนที่แฮชเพื่อจำลองอาร์เรย์มักจะช้ากว่าการใช้อาร์เรย์จริง อย่างไรก็ตาม ตาราง Lua ได้รับการปรับให้เหมาะสมสำหรับการใช้งานเป็นอาร์เรย์เพื่อช่วยหลีกเลี่ยงปัญหานี้^{[ 12 ]}

ความหมายที่ขยายได้เป็นคุณสมบัติสำคัญของ Lua และเมตาเทเบิลช่วยให้สามารถปรับแต่งตารางได้อย่างมีประสิทธิภาพ ตัวอย่างต่อไปนี้แสดงให้เห็นตาราง "อนันต์" สำหรับค่าใดๆnจะfibs[n]ให้ค่าฟิโบนาชn ชี ลำดับที่โดยใช้การเขียนโปรแกรมแบบไดนามิกและการจดจำผลลัพธ์

fibs = { 1 , 1 } -- ค่าเริ่มต้นสำหรับ fibs[1] และ fibs[2] setmetatable ( fibs , { __index = function ( values ​​, n ) --[[__index เป็นฟังก์ชันที่กำหนดไว้ล่วงหน้าโดย Lua  ซึ่งจะถูกเรียกใช้หากคีย์ "n" ไม่มีอยู่]] values ​​[ n ] = values ​​[ n - 1 ] + values ​​[ n - 2 ] -- คำนวณและจดจำค่า fibs[n] return values ​​[ n ] end })

แม้ว่า Lua จะไม่มีแนวคิดเรื่องคลาส ในตัว แต่ก็สามารถจำลองการเขียนโปรแกรมเชิงวัตถุ ได้โดยใช้ฟังก์ชันและตาราง วัตถุจะถูกสร้างขึ้นโดยการใส่เมธอดและฟิลด์ลงในตาราง การสืบทอด (ทั้งแบบเดี่ยวและแบบหลาย) สามารถนำไปใช้ได้โดยใช้เมตาเทเบิลโดยมอบหมายเมธอดและฟิลด์ที่ไม่มีอยู่จริงให้กับวัตถุแม่

เทคนิคเหล่านี้ไม่มีแนวคิดเรื่อง "คลาส" แต่จะใช้ต้นแบบ (prototype ) แทน คล้ายกับ SelfหรือJavaScriptการสร้างอ็อบเจ็กต์ใหม่ทำได้โดยใช้วิธี factory (ซึ่งสร้างอ็อบเจ็กต์ใหม่ตั้งแต่เริ่มต้น) หรือโดยการโคลนอ็อบเจ็กต์ที่มีอยู่แล้ว

การสร้างวัตถุ เวกเตอร์พื้นฐาน:

เวกเตอร์ภายใน= {} เมตาเวกเตอร์ภายใน= { __index = เวกเตอร์}function Vector.new ( x , y , z ) -- ตัวสร้างreturn setmetatable ( { x = x , y = y , z = z } , VectorMeta ) endฟังก์ชันVector.magnitude ( self ) -- อีกวิธีหนึ่งคืนค่าmath.sqrt ( self.x ^ 2 + self.y ^ 2 + self.z ^ 2 ) end​​​​local vec = Vector.new ( 0 , 1 , 0 ) -- สร้างเวกเตอร์print ( vec.magnitude ( vec ) ) -- เรียก ใช้เมธอด (ผลลัพธ์: 1) print ( vec.x ) -- เข้าถึงตัวแปรสมาชิก (ผลลัพธ์: 0)

ในที่นี้setmetatableคำสั่งจะบอกให้ Lua ค้นหาองค์ประกอบในVectorตารางหากไม่พบในvecตารางซึ่งเทียบเท่ากับ จะค้นหา องค์ประกอบในตาราง ก่อน ตาราง อาจไม่มีองค์ประกอบ แต่เมตาเทเบิลของตารางจะส่งต่อการค้นหาไปยังตารางเพื่อค้นหาองค์ประกอบเมื่อไม่พบในตาราง vec.magnitudevec["magnitude"]vecmagnitudevecmagnitudeVectormagnitudevec

Lua มีไวยากรณ์ที่ ช่วยให้เขียนโปรแกรมได้ง่ายขึ้น เพื่ออำนวยความสะดวกในการเขียนโปรแกรมเชิงวัตถุ ในการประกาศฟังก์ชันสมาชิกภายในตารางต้นแบบ (prototype table) เราสามารถใช้ `@ memberfunctions` ซึ่งเทียบเท่ากับ`@memberfunctions` การเรียกใช้เมธอดของคลาสก็ใช้เครื่องหมายโคลอนเช่นกัน: `@memberfunctions` เทียบเท่ากับ `@ memberfunctions` functiontable:func(args)functiontable.func(self,args)object:func(args)object.func(object,args)

ด้วยเหตุนี้ จึงขอเสนอคลาสที่เกี่ยวข้องพร้อม:ไวยากรณ์ที่ช่วยให้เขียนได้ง่ายขึ้นดังนี้:

เวกเตอร์ท้องถิ่น= {} เวกเตอร์. __index = เวกเตอร์ฟังก์ชันVector : new ( x , y , z ) -- ตัวสร้าง-- เนื่องจากนิยามของฟังก์ชันใช้เครื่องหมายโคลอน-- อาร์กิวเมนต์แรกจึงเป็น "self" ซึ่งหมายถึง "Vector" ส่งคืนsetmetatable ({ x = x , y = y , z = z }, self ) endฟังก์ชันVector : magnitude () -- อีกวิธีหนึ่ง-- อ้างอิงถึงอ็อบเจ็กต์โดยปริยายโดยใช้ self คืนค่าmath.sqrt ( self . x ^ 2 + self . y ^ 2 + self . z ^ 2 ) endlocal vec = Vector : new ( 0 , 1 , 0 ) -- สร้างเวกเตอร์print ( vec : magnitude ()) -- เรียกใช้เมธอด (ผลลัพธ์: 1) print ( vec . x ) -- เข้าถึงตัวแปรสมาชิก (ผลลัพธ์: 0)

เป็นไปได้ที่จะใช้เมตาเทเบิลเพื่อเลียนแบบพฤติกรรมของการสืบทอดคลาสใน Lua ^{[ 13 ]}ในตัวอย่างนี้ เราอนุญาตให้เวกเตอร์มีค่าคูณด้วยค่าคงที่ในคลาสที่สืบทอดมา

เวกเตอร์ท้องถิ่น= {} เวกเตอร์. __index = เวกเตอร์ฟังก์ชันVector : new ( x , y , z ) -- ตัวสร้าง-- ในที่นี้ self หมายถึงเมธอด "new" ของคลาสใดก็ตามที่เราเรียกใช้ ในคลาสที่สืบทอดมา self จะ-- เป็นคลาสที่สืบทอดมานั้น ในคลาส Vector self -- จะเป็น Vector ส่งคืนsetmetatable ({ x = x , y = y , z = z }, self ) endฟังก์ชันVector : magnitude () -- อีกวิธีหนึ่ง-- อ้างอิงถึงอ็อบเจ็กต์โดยปริยายโดยใช้ self คืนค่าmath.sqrt ( self . x ^ 2 + self . y ^ 2 + self . z ^ 2 ) end-- ตัวอย่างการสืบทอดคลาสเสมือนlocal VectorMult = {} VectorMult . __index = VectorMult setmetatable ( VectorMult , Vector ) -- ทำให้ VectorMult เป็นลูกของ Vectorฟังก์ชันVectorMult : คูณ( ค่า) คูณตัวเอง. x = คูณตัวเอง. x * ค่า คูณตัวเอง. y = คูณตัวเอง. y * ค่า คูณตัวเอง. z = คูณตัวเอง. z * ค่าส่งคืนตัวเองlocal vec = VectorMult : new ( 0 , 1 , 0 ) -- สร้างเวกเตอร์print ( vec : magnitude ()) -- เรียกใช้เมธอด (ผลลัพธ์: 1) print ( vec . y ) -- เข้าถึงตัวแปรสมาชิก (ผลลัพธ์: 1) vec : multiply ( 2 ) -- คูณส่วนประกอบทั้งหมดของเวกเตอร์ด้วย 2 print ( vec . y ) -- เข้าถึงสมาชิกอีกครั้ง (ผลลัพธ์: 2)

นอกจากนี้ยังสามารถใช้การสืบทอดแบบหลายทาง ได้ โดย__indexอาจเป็นฟังก์ชันหรือตารางก็ได้^{[ 14 ]} ยังสามารถทำการโอเวอร์โหลดตัว__add ดำเนินการได้อีกด้วย เมตาเทเบิลของ Lua สามารถมีองค์ประกอบต่างๆ เช่น และ__subอื่นๆ ได้^{[ 15 ]}

โปรแกรม Lua ไม่ได้ถูกตีความโดยตรงจากไฟล์ Lua ที่เป็นข้อความ แต่จะถูกคอมไพล์เป็นไบต์โค้ด จากนั้นจึงรันบนเครื่องเสมือน Lua (VM) กระบวนการคอมไพล์มักจะมองไม่เห็นสำหรับผู้ใช้ และจะดำเนินการในระหว่างการทำงาน โดยเฉพาะอย่างยิ่งเมื่อ ใช้คอมไพเลอร์ แบบคอมไพล์ทันที (JIT) แต่สามารถทำแบบออฟไลน์เพื่อเพิ่มประสิทธิภาพการโหลดหรือลดการใช้หน่วยความจำของสภาพแวดล้อมโฮสต์โดยการละเว้นคอมไพเลอร์ ไบต์โค้ด Lua ยังสามารถสร้างและเรียกใช้งานได้จากภายใน Lua โดยใช้dumpฟังก์ชันจากไลบรารีสตริงและload/loadstring/loadfileฟังก์ชันต่างๆ Lua เวอร์ชัน 5.5.0 ถูกนำไปใช้ในโค้ด C ประมาณ 32,000 บรรทัด^{[ 3 ]}

เช่นเดียวกับ CPU ส่วนใหญ่ และแตกต่างจากเครื่องเสมือนส่วนใหญ่ (ซึ่งใช้สแต็ก ) เครื่องเสมือน Lua ใช้รีจิสเตอร์ดังนั้นจึงมีความคล้ายคลึงกับการออกแบบฮาร์ดแวร์ส่วนใหญ่มากกว่า สถาปัตยกรรมรีจิสเตอร์ช่วยหลีกเลี่ยงการคัดลอกค่ามากเกินไป และลดจำนวนคำสั่งทั้งหมดต่อฟังก์ชัน เครื่องเสมือนของ Lua 5 เป็นหนึ่งในเครื่องเสมือนบริสุทธิ์แบบใช้รีจิสเตอร์เครื่องแรกที่มีการใช้งานอย่างแพร่หลาย^{[ 16 ]} ParrotและDalvikของAndroidเป็นเครื่องเสมือนแบบใช้รีจิสเตอร์ที่เป็นที่รู้จักกันดีอีกสองเครื่อง เครื่องเสมือนของ PCScheme ก็ใช้รีจิสเตอร์เช่นกัน^{[ 17 ]}

ตัวอย่างนี้คือรายการไบต์โค้ดของฟังก์ชันแฟกทอเรียลที่กำหนดไว้ข้างต้น (ตามที่แสดงโดยluacคอมไพเลอร์ 5.1): ^{[ 18 ]}

ฟังก์ชัน <factorial.lua:1,7> (9 คำสั่ง, 36 ไบต์ ที่ 0x8063c60) 1 พารามิเตอร์, 6 ช่อง, 0 ค่าที่ส่งผ่าน, 6 ตัวแปรโลคอล, 2 ค่าคงที่, 0 ฟังก์ชัน 1 [2] โหลดK 1 -1 ; 1 2 [3] โหลดK 2 -2 ; 2 3 [3] ย้าย 3 0 4 [3] โหลดK 4 -1 ; 1 5 [3] FORPREP 2 1 ; ถึง 7 6 [4] MUL 1 1 5 7 [3] FORLOOP 2 -2 ; ถึง 6 8 [6] คืน 1 2 9 [7] ส่งคืน 0 1 

Lua มีจุดประสงค์เพื่อฝังลงในแอปพลิเคชันอื่น ๆ และมีAPI ภาษา C สำหรับจุดประสงค์นี้ API แบ่งออกเป็นสองส่วน: แกนหลักของ Lua และไลบรารีเสริมของ Lua ^{[ 19 ]}การออกแบบ API ของ Lua ช่วยลดความจำเป็นในการนับการอ้างอิง (การจัดการ) ด้วยตนเองในโค้ด C ซึ่งแตกต่างจาก API ของ Python API เช่นเดียวกับภาษา มีความเรียบง่าย ฟังก์ชันขั้นสูงมีให้โดยไลบรารีเสริม ซึ่งส่วนใหญ่ประกอบด้วยมาโคร พรี โปรเซสเซอร์ที่ช่วยในการดำเนินการตารางที่ซับซ้อน

Lua C API ใช้ โครงสร้างข้อมูลแบบ สแต็ก Lua มีฟังก์ชันสำหรับเพิ่มและลบข้อมูลประเภทพื้นฐานของ C (จำนวนเต็ม ทศนิยม ฯลฯ) ออกจากสแต็ก และมีฟังก์ชันสำหรับจัดการตารางผ่านสแต็ก สแต็กของ Lua แตกต่างจากสแต็กแบบดั้งเดิมอยู่บ้าง ตัวอย่างเช่น สแต็กสามารถเข้าถึงดัชนีได้โดยตรง ดัชนีติดลบแสดงถึงค่าออฟเซ็ตจากด้านบนของสแต็ก เช่น -1 คือด้านบนสุด (ค่าที่เพิ่งเพิ่มเข้าไปล่าสุด) ในขณะที่ดัชนีบวกแสดงถึงค่าออฟเซ็ตจากด้านล่าง (ค่าที่เก่าที่สุด) การส่งข้อมูลระหว่างฟังก์ชัน C และ Lua ก็ใช้สแต็กเช่นกัน ในการเรียกใช้ฟังก์ชัน Lua จะต้องเพิ่มอาร์กิวเมนต์ลงในสแต็ก จากนั้นจึงlua_callใช้อาร์กิวเมนต์นั้นในการเรียกใช้ฟังก์ชันจริง เมื่อเขียนฟังก์ชัน C เพื่อเรียกใช้โดยตรงจาก Lua อาร์กิวเมนต์จะถูกอ่านจากสแต็ก

ต่อไปนี้เป็นตัวอย่างการเรียกใช้ฟังก์ชัน Lua จากภาษา C:

#include <stdio.h> #include <lua.h> // ไลบรารีหลักของ Lua (lua_*) #include <lauxlib.h> // ไลบรารีเสริมของ Lua (luaL_*)int main ( void ) { // สร้างสถานะ Lua lua_State * L = luaL_newstate ( );// โหลดและเรียกใช้สตริงหาก( luaL_dostring ( L , "function foo (x,y) return x+y end" )) { lua_close ( L ); return -1 ; }// ผลักค่าของตัวแปรโกลบอล "foo" (ฟังก์ชันที่กำหนดไว้ข้างต้น) // ลงในสแต็ก ตามด้วยจำนวนเต็ม 5 และ 3 lua_getglobal ( L , "foo" ); lua_pushinteger ( L , 5 ); lua_pushinteger ( L , 3 ); lua_call ( L , 2 , 1 ); // เรียกฟังก์ชันที่มีอาร์กิวเมนต์สองตัวและค่าส่งคืนหนึ่งค่าprintf ( "Result: %d \n " , lua_tointeger ( L , -1 )); // พิมพ์ค่าจำนวนเต็มของรายการที่ด้านบนสุดของสแต็กlua_pop ( L , 1 ); // คืนค่าสแต็กกลับสู่สถานะเดิมlua_close ( L ); // ปิดสถานะ Lua return 0 ; }

เมื่อเรียกใช้ตัวอย่างนี้ จะได้ผลลัพธ์ดังนี้:

$ cc -o example example.c -llua $ ./example ผลลัพธ์: 8

C API ยังมีตารางพิเศษบางตาราง ซึ่งตั้งอยู่ที่ "ดัชนีเสมือน" ต่างๆ ในสแต็ก Lua LUA_GLOBALSINDEXก่อน Lua 5.2 ^{[ 20 ]}คือตาราง globals _Gจากภายใน Lua ซึ่งเป็นเนมสเปซ หลัก นอกจากนี้ยังมีรีจิสทรีที่ตั้งอยู่LUA_REGISTRYINDEXซึ่งโปรแกรม C สามารถจัดเก็บค่า Lua เพื่อเรียกใช้ในภายหลังได้

นอกจากโมดูลไลบรารีมาตรฐาน (แกนหลัก) แล้ว ยังสามารถเขียนส่วนขยายโดยใช้ API ของ Lua ได้อีกด้วย โมดูลส่วนขยายเป็นอ็อบเจ็กต์ที่ใช้ร่วมกันซึ่งสามารถใช้เพื่อขยายฟังก์ชันของตัวแปลภาษาโดยการจัดเตรียมสิ่งอำนวยความสะดวกดั้งเดิมให้กับสคริปต์ Lua สคริปต์ Lua อาจโหลดโมดูลส่วนขยายโดยใช้require[ ^{19 ] เช่น}เดียวกับโมดูลที่เขียนใน Lua เอง หรือด้วยpackage.loadlib[ ^{21 ] เมื่อ}โหลดไลบรารี C ผ่านLua จะค้นหาฟังก์ชันและเรียกใช้ ซึ่งทำหน้าที่เหมือนฟังก์ชัน C ใดๆ ที่สามารถเรียกได้จาก Lua และโดยทั่วไปจะส่งคืนตารางที่เต็มไปด้วยเมธอด ชุดโมดูลที่กำลังเติบโตซึ่งเรียกว่าrocksมีให้ใช้งานผ่านระบบการจัดการแพ็กเกจชื่อLuaRocks [ ^{22 ]}ในลักษณะเดียวกับCPAN , RubyGemsและPython eggs มี การผูก Lua ที่เขียนไว้ล่วงหน้า สำหรับภาษาการ ^{เขียน}โปรแกรมยอดนิยมส่วนใหญ่ รวมถึงภาษาสคริปต์อื่นๆ^{[ 23 ]}สำหรับ C++ มีวิธีการที่ใช้เทมเพลตหลายวิธีและตัวสร้างการผูกอัตโนมัติบางตัว require('foo')luaopen_foo

ในการพัฒนาวิดีโอเกม Lua ถูกใช้กันอย่างแพร่หลายในฐานะภาษาสคริปต์ส่วนใหญ่เป็นเพราะความง่ายในการฝัง การทำงานที่รวดเร็ว และเส้นโค้งการเรียนรู้ที่สั้น^{[ 24 ] เกมที่โดดเด่นที่ใช้ Lua ได้แก่ Roblox [} 25 ] ^{Garry 's Mod} , World of ^{Warcraft ,} Payday 2 , Project Zomboid , Phantasy Star Online 2 , Dota 2 , Crysis [ ^{26 ] และอีกมากมาย นอกจากนี้ Lua ยัง}ถูกใช้ในซอฟต์แวร์ที่ไม่ใช่วิดีโอเกม เช่นAdobe Lightroom , Moho , iClone , Aerospikeและซอฟต์แวร์ระบบบางตัวในFreeBSDและNetBSDและใช้เป็นภาษาสคริปต์เทมเพลตบนMediaWikiโดยใช้ส่วนขยาย Scribunto ^{[ 27 ]}

ในปี พ.ศ. 2546 ผลสำรวจที่จัดทำโดย GameDev.net แสดงให้เห็นว่า Lua เป็นภาษาสคริปต์ที่ได้รับความนิยมมากที่สุดสำหรับการเขียนโปรแกรมเกม^{[ 28 ]}เมื่อวันที่ 12 มกราคม พ.ศ. 2555 Lua ได้รับการประกาศให้เป็นผู้ชนะรางวัล Front Line Award 2011 จากนิตยสารGame Developerในหมวดเครื่องมือการเขียนโปรแกรม^{[ 29 ]}

Many non-game applications also use Lua for extensibility, such as LuaTeX, an implementation of the TeX type-setting language; Redis, a key-value database; ScyllaDB, a wide-column store, Neovim, a text editor; Nginx, a web server; Wireshark, a network packet analyzer; Discordia, a Discord API library; and Pure Data, a visual audio programming language (through the pdlua extension).

• MoonScript is a dynamic, whitespace-sensitive scripting language inspired by CoffeeScript, which is compiled into Lua. This means that instead of using do and end (or { and }) to delimit sections of code it uses line breaks and indentation style.^[30][31][32] A notable use of MoonScript is the video game distribution website Itch.io.
• Haxe supports compiling to some Lua targets, including Lua 5.1–5.3 and LuaJIT 2.0 and 2.1.
• Fennel, a Lisp dialect that targets Lua.^[32]
• Urn, a Lisp dialect built on Lua.^[33]
• Amulet, an ML-like functional programming language, which compiler emits Lua files.^[34]
• LunarML, Standard ML compiler that produces Lua/JavaScript^[35]

• LuaJIT, a just-in-time compiler of Lua 5.1.^[36][37]
• Luau developed by Roblox Corporation, a derivative of and backwards-compatible with Lua 5.1 with gradual typing, additional features, and a focus on performance.^[38] Luau has improved sandboxing to allow for running untrusted code in embedded applications.^[39]
• Ravi, a JIT-enabled Lua 5.3 language with optional static typing. JIT is guided by type information.^[40]
• Shine, a fork of LuaJIT with many extensions, including a module system and a macro system.^[41]
• Glua ซึ่งเป็นเวอร์ชันที่แก้ไขแล้วฝังอยู่ในเกมGarry's Modในฐานะภาษาสคริปต์^{[ 42 ]}
• Teal เป็นภาษาถิ่น Lua ที่มีการกำหนดประเภทแบบคงที่ ซึ่งเขียนด้วยภาษา Lua ^{[ 43 ]}
• PICO-8ซึ่งเป็น "เครื่องเล่นเกมคอนโซลในโลกแฟนตาซี" ใช้ภาษา Lua เวอร์ชันย่อยที่เรียกว่า PICO-8 Lua
• Pluto ซึ่งเป็นซูเปอร์เซ็ตของ Lua 5.4 ที่นำเสนอไวยากรณ์ ไลบรารี และประสบการณ์การพัฒนาที่ดียิ่งขึ้น ในขณะเดียวกันก็ยังคงเข้ากันได้กับ Lua ทั่วไป^{[ 44 ]}

นอกจากนี้ ชุมชนผู้ใช้ Lua ยังจัดเตรียมแพทช์ที่มีประสิทธิภาพ เพิ่มเติม บนการใช้งาน C อ้างอิง อีกด้วย ^{[ 45 ]}

• การเปรียบเทียบภาษาโปรแกรม
• Löve (เฟรมเวิร์กเกม)

• Ierusalimschy, R. (2013) การเขียนโปรแกรมในภาษาลัวะ (ฉบับที่ 3) Lua.org ไอเอสบีเอ็น 978-85-903798-5-0.(ฉบับพิมพ์ครั้งที่ 1 มีให้ดาวน์โหลดทางออนไลน์ )
• Gutschmidt, T. (2003). การเขียนโปรแกรมเกมด้วย Python, Lua และ Ruby . Course Technology PTR. ISBN 978-1-59200-077-7.
• ชูยเทมา, ป.; มาเยน, เอ็ม. (2005) การพัฒนาเกมด้วย Lua . ชาร์ลส์ ริเวอร์ มีเดียไอเอสบีเอ็น 978-1-58450-404-7.
• จุง, เค.; บราวน์, เอ. (2007). การเขียนโปรแกรม Lua เบื้องต้น . สำนักพิมพ์ Wrox . ISBN 978-0-470-06917-2เก็บถาวรจากต้นฉบับเมื่อวันที่ 8 กรกฎาคม 2561 เรียกดูเมื่อวันที่ 7 กรกฎาคม 2561
• ฟิเกเรโด, LH; เซเลส ว.; Ierusalimschy, R., eds. (2551) อัญมณีการเขียนโปรแกรม Lua Lua.org ไอเอสบีเอ็น 978-85-903798-4-3.
• Takhteyev, Yuri (2012). Coding Places: Software Practice in a South American City . The MIT Press . ISBN 978-0-262-01807-4เก็บถาวรจากต้นฉบับเมื่อวันที่ 2 พฤศจิกายน 2012บทที่ 6 และ 7 กล่าวถึงภาษา Lua โดยเฉพาะ ในขณะที่บทอื่นๆ จะกล่าวถึงซอฟต์แวร์ในบราซิลในวงกว้างขึ้น
• วาร์มา, จายันต์ (2012). เรียนรู้ภาษา Lua สำหรับการพัฒนาเกม iOS . สำนักพิมพ์ Apress . ISBN 978-1-4302-4662-6.
• Matheson, Ash (29 เมษายน 2546). "บทนำเกี่ยวกับ Lua" . GameDev.net . เก็บถาวรจากต้นฉบับเมื่อ 18 ธันวาคม 2555 . สืบค้นเมื่อ3 มกราคม 2556 .
• Fieldhouse, Keith (16 กุมภาพันธ์ 2549). "แนะนำ Lua" . ONLamp.com . O'Reilly Media . เก็บถาวรจากต้นฉบับเมื่อ 12 มีนาคม 2549 . เรียกดูเมื่อ28 กุมภาพันธ์ 2549 .
• Streicher, Martin (28 เมษายน 2549). "การเขียนสคริปต์แบบฝังตัวด้วย Lua" . developerWorks . IBM . เก็บถาวรจากต้นฉบับเมื่อ 2 กรกฎาคม 2552 . สืบค้นเมื่อ7 กรกฎาคม 2561 .
• Quigley, Joseph (1 มิถุนายน 2550). "การพิจารณาภาษา Lua" . Linux Journal .
• แฮมิลตัน, นาโอมิ (11 กันยายน 2008). "AZ แห่งภาษาโปรแกรม: Lua" . คอมพิวเตอร์เวิลด์ . IDG . เก็บถาวรจากต้นฉบับเมื่อ 8 กรกฎาคม 2018 . สืบค้นเมื่อ7 กรกฎาคม 2018 .บทสัมภาษณ์กับ โรแบร์โต อิเอรูซาลิมชี
• เอียรูซาลิมชี่, โรแบร์โต; เด ฟิเกเรโด้, ลุยซ์ เฮนริเก้; เซเลส, วัลเดมาร์ (12 พฤษภาคม 2554). “ถ่ายทอดภาษาผ่านรูเข็ม ” คิว ACM . 9 (5): 20– 29. ดอย : 10.1145/1978862.1983083 . S2CID  19484689 .ความสามารถในการฝังตัวของ Lua ส่งผลต่อการออกแบบอย่างไร
• เอียรูซาลิมชี่, โรแบร์โต; เด ฟิเกเรโด้, ลุยซ์ เฮนริเก้; เซเลส, วัลเดมาร์ (26 ตุลาคม 2018). “ส่องการออกแบบของหลัว” . การ สื่อสารของ ACM 61 (11): 114– 123. ดอย : 10.1145/3186277 . S2CID  53114923 .
• เอกสารและวิทยานิพนธ์ภาษา Lua

เว็บไซต์ Wikibooks มีหนังสือเกี่ยวกับหัวข้อ: การเขียนโปรแกรมภาษา Lua

• เว็บไซต์อย่างเป็นทางการ
• ผู้ใช้งาน Lua ถูกเก็บถาวรเมื่อวันที่ 16 ธันวาคม 2010 ที่Wayback Machineหมวดชุมชน
• ฟอรัม Lua ถูกเก็บถาวรเมื่อวันที่ 28 กันยายน 2021 ที่Wayback Machine
• ลูอาดิสท์
• Lua Rocks - ตัวจัดการแพ็กเกจ
• โปรเจ็กต์ในภาษา Lua