**Please read the full text**
This is the new eternity and most of the analyzer bugs and other bugs have been fixed
But what is this program and what does it do? Is this program a reason why VS Code should not be used anymore?
Well, I have been working on a code editor for a long time that can detect and rank a lot of security and optimization problems and obsolete codes and show the structure of your codes in the outline section. In addition to the analyzer and… it has the ability to change the theme and color the codes and a lot of other things.
# Luau Code Analyzer
A built-in code analyzer designed specifically for Roblox Luau development. It scans your code directly inside the editor and identifies performance issues, deprecated APIs, potential security risks, and common coding problems.
## Performance and Best Practices
The analyzer checks for a wide range of performance and code-quality issues, including:
> * Detecting outdated `wait()` usage and recommending `task.wait()`
> * Detecting infinite loops that run without yielding
> * Understanding when a loop already yields through a function call
> * Detecting `repeat ... until false` loops that may run indefinitely
> * Detecting event connections that are never disconnected
> * Recommending proper connection cleanup with `:Disconnect()`
> * Recommending `game:GetService()` instead of direct service access
> * Detecting inefficient `Instance.new(...).Parent = ...` patterns
> * Checking newly created `Part` and `MeshPart` objects for explicit collision settings
> * Detecting heavy math operations inside loops
> * Detecting multiple `string.split()` calls on the same line
> * Detecting multiple `task.wait()` calls on the same line
> * Recommending `task.spawn()`, `task.delay()`, and `task.defer()` instead of their older alternatives
> * Detecting cases where `ipairs()` may be more appropriate than `pairs()`
> * Recommending safer error handling with `pcall()`
> * Checking animation code for potentially undefined `Animator` objects
> * Checking Promise usage for missing error handling with `:catch()`
> * Detecting global debounce variables that could cause conflicts between scripts
> * Checking UI access for potentially missing or nil objects
> * Checking `Humanoid.Touched` usage for potentially problematic patterns
## Deprecated Roblox API Detection
The analyzer detects a variety of deprecated and legacy Roblox APIs and suggests modern alternatives where appropriate.
Some of the APIs and patterns it checks include:
> * `BodyVelocity`
> * `BodyGyro`
> * `BodyPosition`
> * `BodyForce`
> * `BodyThrust`
> * `BodyAngularVelocity`
> * `HopperBin`
> * `:Remove()`
> * `:connect()`
> * `:disconnect()`
> * `Workspace:FindPartOnRay()`
> * `Workspace:FindPartOnRayWithIgnoreList()`
> * `Terrain:ClearCells()`
> * `FilterStringForBroadcastAsync()`
> * Legacy `Mouse.Button1Down`
> * Numeric Enum indexing
> * Invalid `Instance.new("DataModel")`
> * Incorrect API casing such as `game:Getservice()`
The analyzer doesn't just flag deprecated APIs; it also provides an explanation of what should be used instead.
## Security and Suspicious Code Detection
The analyzer also checks for code patterns that may indicate unsafe, suspicious, obfuscated, or exploit-related code.
It can detect:
> * `loadstring()`
> * `loadfile()`
> * `getfenv()` and `setfenv()`
> * `getgenv()`
> * `writefile()` and `readfile()`
> * `hookfunction()`
> * `debug.getupvalue()`
> * `debug.setupvalue()`
> * `debug.sethook()`
> * Potentially suspicious use of `bit32`
> * `HttpGet()` combined with `loadstring()`
> * `require()` combined with `HttpGet()`
> * Obfuscated `string.char()` usage feeding into `loadstring()` or `pcall()`
> * `__metatable` manipulation
> * Infinite loops created through `task.spawn()`
Security findings can have different severity levels, ranging from low-level warnings to critical issues.
## Context-Aware Analysis
The analyzer is not limited to simple keyword matching. It also examines the surrounding code to make better decisions.
It can analyze:
> * Code before and after the current line
> * Enclosing `do`, `then`, `function`, and `repeat` blocks
> * Function bodies
> * Functions that call other functions
> * Whether a loop yields directly
> * Whether a loop yields indirectly through another function
> * Whether a loop can exit using `break` or `return`
> * Multi-line strings and comments
> * Single-line comments and string literals
This allows the analyzer to reduce false positives and distinguish between genuinely problematic code and code that is already handling the situation correctly.
## Comment and String Awareness
The analyzer understands that code-like text inside comments and strings should not normally be treated as actual code.
It handles:
> * Single-line comments
> * String literals
> * Multi-line strings
> * Multi-line comments
Before analysis, these sections are masked while preserving line numbers, preventing keywords inside comments or strings from interfering with the analysis.
## Findings and Severity
Every detected issue includes:
* The exact line number
* A description of the problem
* The issue category
* The severity level
* The original source-code line
Findings are then sorted by severity so that the most important issues appear first.
The analyzer supports several severity levels:
**Critical, High, Medium, Low, and Info.**
## Reliable Analysis Engine
The analyzer is designed so that an error in one individual rule does not crash the entire analyzer.
download link: File sharing and storage made simple