Legendry code editor + download

[amindez24]

First of all, I apologize for making the download path long. I want to give you a community explanation with the source.
Why should we use this code editor? The high speed of this code editor can execute 100 thousand lines of code with less than 200 MB of RAM and most importantly, it has 100 algorithms to detect dangerous and unoptimized code and can detect obsolete code, which are the main reasons to download this code editor.
The next point is the outline section, which shows you the functions so that you can see the skeleton of your project.
If you have any ideas or suggestions, you can tell me here so that I can read and implement them.

amindez24

1. Roblox Luau Script Analyzer

2. A powerful static code analysis system for Roblox Studio / Luau that analyzes scripts line by line and identifies issues related to Performance, Best Practices, Deprecated APIs, Potential Errors, Security Risks, and Obfuscation.

3. Performance & Best Practices

4. The analyzer checks for the following patterns and potential issues:

5. • Detects the use of wait() and recommends task.wait()
6. • Detects infinite while true do loops that do not contain task.wait() or wait() and may cause excessive CPU usage or freezing
7. • Detects repeat ... until false loops without a yielding mechanism
8. • Checks Event Connections created with :Connect() that may not have a corresponding :Disconnect()
9. • Detects deeply nested and direct Instance access and recommends FindFirstChild() to reduce potential nil errors
10. • Recommends using game:GetService() instead of directly accessing services such as game.Workspace and game.ReplicatedStorage
11. • Recommends ipairs() for array-like Tables instead of pairs()
12. • Detects the use of error() without appropriate error handling such as pcall() / xpcall()
13. • Analyzes Instance.new() usage and recommends caching/configuring the Instance before assigning its Parent
14. • Checks TweenInfo.new() calls for missing or unspecified parameters
15. • Analyzes UserInputService:BindAction() usage and recommends more appropriate input-handling approaches where applicable
16. • Checks MeshPart creation and warns about potential Collision configuration issues
17. • Detects expensive math.* operations inside loops
18. • Detects Promise.new() usage and recommends handling failures with :Catch()
19. • Recommends PathfindingService instead of Workspace:MoveTo() for Humanoid movement where appropriate
20. • Detects the use of BodyVelocity on HumanoidRootPart
21. • Checks Part objects created with Instance.new("Part") when CanCollide is not explicitly configured
22. • Detects direct CFrame assignments and may recommend TweenService for smoother movement
23. • Checks direct use of Touched on Humanoids
24. • Detects multiple string.split() calls on the same line and recommends splitting once and reusing the result
25. • Checks Debounce variables and recommends making them local where appropriate
26. • Detects UI element access without nil checks
27. • Detects multiple task.wait() calls on the same line
28. • Recommends task.spawn() instead of spawn()
29. • Recommends task.delay() instead of delay()
30. • Recommends task.defer() instead of defer()
31. • Detects game:GetObjects() usage and recommends newer API approaches where applicable
32. • Detects WaitForChild() without a timeout and warns about potential Infinite Yield
33. • Checks LoadAnimation() usage before confirming that an Animator exists

34. This section is directly implemented through a collection of dedicated Performance / Best Practice rules.

35. ---

36. Deprecated Roblox API Detection

37. The analyzer also detects the use of older or deprecated Roblox APIs and syntax, including:

38. The analyzer also performs dedicated checks for:

39. • Numeric indexing of Enum values
40. • Invalid or deprecated usage of Instance.new("DataModel")
41. • Various legacy APIs and syntax patterns, including replacement recommendations

42. Deprecated Roblox APIs are implemented as independent analyzer rules, allowing them to be detected and reported separately.

43. ---

44. Security & Obfuscation Detection

45. One of the major components of the analyzer is the detection of suspicious security-related patterns, exploit indicators, runtime manipulation, and code obfuscation techniques.

46. The system detects patterns such as:

47. • debug.traceback
48. • debug.getupvalue
49. • debug.setupvalue
50. • debug.sethook
51. • hookfunction()
52. • bit32.*
53. • os.execute()
54. • io.popen()
55. • writefile()
56. • readfile()
57. • getgenv()
58. • Global variables named shared
59. • loadstring()
60. • loadfile()
61. • getfenv()
62. • setfenv()

63. The analyzer also detects more complex patterns.

64. Remote Code Execution Patterns

65. • Detects combinations of HttpGet() + loadstring()
66. • Detects require() combined with HttpGet()
67. • Identifies code retrieved from remote sources and dynamically executed at runtime

68. Obfuscation Detection

69. The analyzer can detect:

70. • Suspicious use of select() combined with variadic unpacking (...)
71. • wait(math.random(...)) as a potentially suspicious or obfuscated delay pattern
72. • Extremely long strings containing excessive escape sequences
73. • Unicode escape sequences such as \uXXXX
74. • Hex escape sequences such as \xXX
75. • loadstring(string.char(...))
76. • pcall(loadstring(string.char(...)))
77. • Combinations of __index and rawget
78. • __call overrides using setmetatable
79. • __metatable overrides using setmetatable
80. • task.spawn() combined with repeat ... until false loops

81. These checks are designed to identify potential exploit behavior, dynamic code loading, runtime manipulation, and obfuscation patterns.

82. Important: A security warning does not automatically mean that the code is malicious. These patterns may have legitimate uses, so human review is still recommended.

83. ---

84. Context-Aware Analysis

85. The analyzer does not rely exclusively on isolated line-by-line pattern matching.

86. For certain rules, the system can analyze:

87. • Lines before the current line
88. • Lines after the current line
89. • Larger sections of the current code block
90. • Structures such as do ... end
91. • function ... end
92. • then ... end
93. • repeat ... until

94. This allows certain warnings to be generated based on the context surrounding the code, rather than simply matching an individual pattern on a single line.

95. ---

96. Smart Comment & String Handling

97. Before executing many of its rules, the analyzer processes the source code to reduce false positives.

98. It can:

99. • Ignore the contents of Strings during normal analysis
100. • Mask single-line comments
101. • Preserve the original line length so Pattern locations remain unchanged
102. • Prevent normal rules from triggering on patterns found inside Comments or Strings

103. However, Security rules intentionally analyze certain patterns on the Raw Line, allowing potentially suspicious patterns hidden inside Strings to still be detected.

104. ---

105. Robust Analysis Engine

106. The analyzer follows a structured analysis pipeline:

107. 1. Receives the Luau source code
108. 2. Splits the source code into individual lines
109. 3. Ignores comment-only lines
110. 4. Runs all registered rules against the source
111. 5. Provides the appropriate Context to each rule
112. 6. Stores every Finding with:
113. • Line number
114. • Warning message
115. • Category
116. • The relevant source code
117. 7. If a Rule throws an Exception, the entire Analyzer does not stop. The problematic rule is safely skipped and analysis continues with the remaining rules.

118. As a result, every detected issue can be reported with:

119. Line Number + Message + Category + Code

120. ---

121. Warning Categories

122. All Findings are organized into three primary categories:

123. • Style / Performance / Best Practice
124. • Deprecated API
125. • Security / Obfuscation

[IIIIlIIlllIlIlll]

Model:MoveTo(), Humanoid.PlatformStand, ParticleEmitter.Rate, Workspace.CurrentCamera, SoundService:PlayLocalSound(), StarterGui:SetCore(), Humanoid:Move(), Decal.Texture, StarterPlayerScripts, MarketplaceService:PromptPurchase() and HttpService:JSONEncode() are not deprecated.
LocalizationService:GetCountryRegionForPlayer(), SoundService:RegisterStreamTrack(), PlayerGui:ClearAllChildren() (that’s an Instance method), Backpack:Equip(), Terrain:ClearCells(), GetPlayerByName(), TextBox.TextChanged and Enum.Channels simply do not exist.
GuiService:SetMenuIsOpen() is RobloxScriptSecurity.
Holy AI hallucination

[amindez24]

Of course, I gave nearly a few thousand lines of code to the AI ​​to analyze, so there may be errors because as far as I know, the analyzer has no problems.

[whosjacko (Jacko)]

Where is the source code? Also this gets flagged on VirusTotal

[amindez24]

[amindez24]

Maybe the reason is that there are things like obfuscations written in the codes and the antivirus thinks these are the program codes that have been obfuscated.

[whosjacko (Jacko)]

It’s highly possible. But you need to upload the source code on github (or here), not just the exe build; otherwise people will think it’s malicious

[amindez24]

Yes, but I don’t like people cutting up my files and putting them in their own names. There are many who are masters of copying.

[amindez24]

You can cry about the lack of open source for copying projects, that’s your problem.
And if the name of this masterpiece is illusion, I’m proud of it, and you can cry about it too, because now everyone else is proud of it too.