🐞⚔️ #bugfix
The recent problem where scripts that used to run fine suddenly started timing out on the >20000ms message should now be fixed.

🐞⚔️ #bugfix
There was a bug in the parser of published scripts descriptions that caused the # character in urls to be silently replaced by %, rendering links dysfunctional. The bug has been fixed.

🌲 #newfeature
The following functions now accept a series int argument for their length= parameter, which means the length can now vary with conditions that may change during the script's execution:
highest()
lowest()
highestbars()
lowestbars()

This is an example where we use a long length when price is above an MA, and a shorter length when price is below the MA:

//@version=4
study("Dynamic highest()", "", true)
ma = sma(close, 50)
var float hi = na
long = close > hi
hi := highest(high, high > ma ? 200 : 20)
plot(hi, "High", color.purple, 1, plot.style_circles)
plot(ma, "MA", color.silver)
plotchar(long, "long", "▲", location.belowbar, color.lime, size = size.tiny)

https://www.tradingview.com/x/fW3oqnqm/

🔈 #news
Script memory usage is now monitored. You may receive the following error on complex scripts:

Memory limits exceeded. The study allocates `x` bytes, max allowed is `y` bytes

See this Help Center document for more information, and please report occurrences in the Pine Script chat on TV.

🔈 #news
Our selection of the best open-source indicators is now available in realtime, in a new "Editors' Picks" section of the Scripts stream. They will soon be integrated to TradingView's homepage.

We will continue to publish a separate, periodic roundup of the best Pine Utilities in Ideas from the PineCoders account on TV.

🔈 #news
More on the "Memory limits exceeded" error message

The memory management logic that caused the error yesterday was turned off at the end of the day. It will soon be reactivated. While it will cause inconveniences, this step paves the way for significant improvements for most coders and users.

Previously, a few scripts consuming large amounts of memory often caused load imbalances that negatively impacted the execution time of many more "normal" scripts on the platform. Additionally, the advent of line and label drawings, and arrays very soon, put additional strain on resource consumption. Because there was previously no supervision of memory used by scripts, artificially low limits were imposed on features such as drawings.

Supervising memory usage will streamline resource use across all scripts on the platform, which will in turn allow the Pine team to increase the number of drawings allowed, provide a smoother environment for the coming arrays to operate in, and improve execution time for the majority of scripts on the platform. We believe these benefits largely offset the efforts that will be required for the few coders of resource-hungry scripts to optimize or adapt their scripts.

Note that the most frequent cause for the error involves the use of max_bars_back = 5000 in scripts, which is often unnecessary. See this Help Center page for more information on how to avoid the error, and this page to understand how to use max_bars_back correctly.

🔈 #news
Compile times are now 1.5 to 2 times faster.
https://www.tradingview.com/blog/en/pine-script-became-faster-20007/

🔈 #news
We have added a new link in the Unicode section of our Resources document. "Amp What" allows you to search Unicode characters by keyword:
https://www.pinecoders.com/resources/#unicode-characters

🔈 #news
Pine cannot determine the referencing length of a series. Try using max_bars_back

Pine team's continued efforts to optimize memory use will in the next weeks lead to more scripts encountering the max_bars_back error message.

What's happening is that the default historical buffer size of 300 bars allocated to variables will gradually be decreased to 1 bar, as is currently the case with functions. You will thus need to use max_bars_back to explicitly allocate buffer size in some scripts that did not require it before.

A new Help Center page explains the details of what the historical buffer size is, how it works and how you can control it using max_bars_back in two different ways.
https://www.tradingview.com/?solution=43000587849

💪 #tip
Why do the OHLC built-ins sometimes return different values than the ones shown on the chart?
See the answer in our new FAQ entry.

🐞⚔️ #bugfix
Using a function call as an argument in another function call often threw an error. The problem is now fixed.

🌲 #newfeature
You can now use dynamic lengths (series int) with these functions.
Although it may be handy to use floats to calculate lengths dynamically, please remember to cast them to an "int" before using them in function calls, as we do in our example. Also keep in mind that, as usual, these functions require evaluation on every bar, so should be used outside for loops and if blocks not executed on every bar:

alma()
change()
highest()
highestbars()
linreg()
lowest()
lowestbars()
mom()
sma()
sum()
vwma()
wma()

🔈 #news
Memory monitoring
TradingView will ease down on the gradual tightening of script memory usage for the next month. This will allow for the imminent deployment of arrays to proceed without interference from changes related to memory monitoring.

Barring any unforeseen need to make adjustments during the coming month, the script memory monitoring process will resume after that period.

🔷 Why monitor memory usage?
The main reason why script memory usage needs to be managed is to ensure a more fair and efficient use of the infrastructure by script users. Another positive outcome expected out of the process will be the possibility to relax some arbitrary limits imposed on the use of other script resources such as drawings and plots.

🔷 Why make the process gradual?
TradingView decided to make the process gradual because this will make it possible to achieve the highest working limit for allowed memory per script. As a result, a smaller number of scripts will have been affected by the time the optimal limit is reached. If TV had decided to impose an arbitrarily low limit such as the very ones they wish to relax for drawings and plots, a much larger number of scripts would have been affected. The gradual approach, however, entails that the few authors of scripts making heavy use of memory resources may need to adapt their scripts a few times if their first adaptations keep their scripts too close to the limit.

🔷 Tips to reduce memory use in your scripts
The two most frequent causes for heavy memory use in Pine scripts are:
1. The use of large numbers of security() calls.
2. Using large values for max_bars_back.

To reduce the number of security calls in your scripts, ensure you maximize security()'s potential to return tuples. Using tuples, it is no longer necessary to make multiple calls to fetch different values from the same ticker/HTF.

Concerning the historical buffer controlled by max_bars_back, read this Help Center page if you haven't done so already:
https://www.tradingview.com/scripts/editors-picks/?solution=43000587849
It explains in detail what the historical buffer is. Recall from our previous announcement that the historical buffer for variables will eventually be reduced to 1, as it already is for function calls. This entails that all scripts making use of historical values of variables will require explicit management of the buffer.
Do NOT adopt the easy solution to add max_bars_back = 5000 to your study() or strategy() declaration statement, as this will most likely condemn you to adapt your script again in the future. Only use max_bars_back in your declaration statement if you need a historical buffer for function calls. If you only need a buffer for variables, use the max_bars_back() function on those specific variables only, and limit the buffer's size to the minimum required by your script.
Also, keep in mind that when you declare a certain historical buffer size, capping the offset you use with the history-referencing operator so that it does not exceed that buffer size will prevent your script from throwing runtime errors.

🌲 #newfeature
Welcome to a new dimension: Arrays are here
https://www.tradingview.com/blog/en/arrays-are-now-available-in-pine-script-20052/

💪 #tip
See all our tricks to organize script Inputs in this FAQ entry:
https://www.pinecoders.com/faq_and_code/#how-can-i-organize-my-scripts-inputs-in-the-settingsinputs-tab

🐞⚔️ #bugfix
Fixes have come in today
— The Editor's Undo now works after saves.
— The cursor's position in the Editor is preserved after saves.
— Search & Replace now allows for replacement with an empty string.

🌲 #newfeature
You can now see which scripts an author commented on in his SCRIPTS tab.

🌲 #newfeature
You can now see which scripts you liked in your user's profile's SCRIPTS tab.

🌲 #newfeature
input() now supports type = input.color

https://www.tradingview.com/blog/en/create-color-inputs-in-pine-20751/