LSL-PyOptimizer online

Paste here the script that you want to optimize, select the desired optimization options below and press the Optimize button.

Optimization options

Enable optimizations.

Reduce identifier length for globals, functions, states and parameters ("minify"). Those identifier names take code space; local variables and labels don't. It also reuses some system names which are always used. Note that this reduces the script to unreadable gibberish, making it difficult to debug. However, the gains from this tend to be significant in long scripts with lots of globals. See also the option at the bottom to add the original script as a comment.

Constant folding: Resolve constant expressions to their value, and eliminate some statements (e.g. if a while loop's condition is always false, remove it)

Concatenate constant strings when possible.

Convert llGetListLength(myList) to (myList != [])

Swap if and else when the negated condition produces shorter code.

Convert lists into additions. Transforms lists of the form [a, b, c, ...] into (list)a + b + c + ... if possible.

Dead code removal: removes unused variables, functions and states; also eliminates statements detected to never execute.

Optimize signs. The sign in negative constants everywhere except in globals and in a type cast, takes 1 byte. This saves that byte by wrapping the constant in a typecast (type casting to the same type doesn't add any overhead in Mono).

Optimize floats without decimals. This represents a float that has no decimals as an integer, because floats take 8 bytes but when represented like this, they take 4 bytes for the integer plus 1 for the type conversion, yielding a total saving of 3 bytes.

Syntax extensions

Enable use of 'break' and 'continue' statements in loops (with an optional numeric parameter for the number of loops to break or to continue at)

Allow expressions in globals, as long as they resolve to a constant. For example: float PI_BY_FOUR = PI / 4; float SIN_2 = llSin(2);... Needs constant folding active.

Allow concatenating strings and keys without needing a typecast (result is string).

Allow using unary prefix expressions after a typecast, not just postfix. For example, (list)!x, (string)(integer)x...

Enable C-style string juxtaposition. For example, "ab" "cd" gives "abcd". It's similar to concatenation, but only for constant strings.

Enable C-style switch statements (TPV preprocessor compatible).

Emit an error when the default label is missing in a switch statement.

Enable "lazy list" syntax (TPV preprocessor compatible), making lists look like arrays to the programmer, e.g. mylist[3] = 5; or integer i = (integer)mylist[2];

Enable function override: if a function with the same name as a previous one is declared, it overrides the previous declaration rather than giving an error about being duplicate. For compatibility with the TPV optimizer.

Allow duplicate labels: if a function has duplicate labels that are allowed by the syntax (because they are protected by scope rules), the standard compiler disallows them, generating weird errors or misbehaving. Enable them here.

Extended assignments: allows using |=, &=, ^=, <<= and >>=.

Manual function inlining (EXPERIMENTAL): Add inline after the close parenthesis of the parameter list in a function declaration, to make it work as a macro.

Information options

Add the original script at the beginning, in a format compatible with TPVs' preprocessor. Pasting the script with the preprocessor disabled and saving, and then enabling the preprocessor, will let you see the original script in the main tab and the optimized script in the preprocessed tab.

Add a timestamp as a comment.

LSL-PyOptimizer online

Script

Options

Optimization options

Syntax extensions

Information options

Additional information