Pine Script 2025 Developer Updates

Pine Script received a steady stream of developer experience improvements throughout 2025 that changed how scripts are written, how code is organized, and how much the language can handle¹. While headline features like footprint requests and bid/ask variables grabbed attention, four under-the-radar changes to the development environment had an outsized impact on day-to-day scripting productivity. This article covers each of those improvements in detail: the removal of the 550-scope limit, the 10x string length increase, the redesigned Pine Editor, and the relaxed line wrapping rules.

If you write Pine Script indicators or strategies regularly, these quality-of-life changes affect nearly every session in the editor. Understanding what changed and why it matters will help you write cleaner code, avoid legacy workarounds, and take full advantage of the modernized development environment.

February 2025: Unlimited Local Scopes

The most impactful developer experience change of 2025 arrived in the very first update of the year. In February, TradingView removed the hard limit of 550 local scopes per script, allowing scripts to contain as many scopes as needed¹.

What Are Scopes in Pine Script

A scope in Pine Script is a section of indented code that represents a distinct execution context⁴. Every script has one global scope consisting of non-indented code. Local scopes are created by indented code blocks inside control structures and function definitions. Specifically, each of the following constructs creates a local scope:

• if and else if blocks create a scope for each branch of the conditional
• for loops create a scope for the loop body
• while loops create a scope for the loop body
• switch statements create a scope for each case
• User-defined functions and methods create a scope for the function body

Scripts can also contain up to 1,000 variables within each individual scope, which is a separate limit that still applies⁴. But the total number of scopes across the entire script was capped at 550 before this update.

Why the Limit Was a Problem

The 550-scope ceiling was a frequent obstacle for advanced script developers. Consider a strategy that uses nested conditional logic for trade management. An entry system with three conditions, a risk management module with stop-loss and take-profit branches, and a position sizing function with conditional scaling could easily consume dozens of scopes. Add a multi-timeframe scanner that checks conditions across several instruments, and the count climbs quickly.

Developers hit this limit most often in three scenarios:

• Multi-asset scanners that evaluate conditions for many symbols inside loops with conditional branches
• Complex risk management systems with many conditional paths for different market conditions
• Strategy templates with extensive configuration options where each option creates conditional execution branches

When a script exceeded 550 scopes, the compiler would reject it with an error message. The only solution was to restructure the code, typically by consolidating conditional branches, replacing if chains with switch statements where possible, or splitting the script into a library and a main script. These workarounds made code harder to read and maintain.

What Changed

After the February 2025 update, Pine Script no longer enforces any limit on the number of local scopes¹. Scripts can contain thousands of scopes without hitting a compilation error. This means developers can write code naturally, using as many conditional branches, loops, and helper functions as the logic requires, without counting scopes or restructuring code to stay under an artificial ceiling.

If you previously restructured scripts to avoid the scope limit, you can now refactor them back to their more readable form. Functions that were inlined to save scopes can be extracted again. Conditional branches that were collapsed into ternary operators for scope efficiency can be expanded into full if/else blocks.

Practical Impact

The removal of this limit was particularly valuable for developers building automated trading strategies. A strategy that generates signals for TradingView webhook automation often needs complex conditional logic to determine entry timing, position sizing, stop placement, and exit conditions. Each of those decision branches creates scopes. With the limit removed, developers can focus on writing correct, readable logic rather than optimizing for scope count.

August 2025: 10x String Length Increase

The August 2025 update increased the maximum string length in Pine Script from 4,096 characters to 40,960 characters¹, a 10x improvement that removed a common bottleneck for text-heavy scripts.

Where the Old Limit Hurt

The previous 4,096-character limit affected several categories of scripts:

• Scripts that build detailed tooltip text for labels, showing multi-line analysis summaries or formatted data tables
• Dashboard indicators that construct large table cell contents with concatenated strings
• Alert message generators that produce structured JSON payloads for webhook delivery
• Pine Logs output that includes comprehensive diagnostic information for debugging
• Scripts that use str.format() to build formatted reports combining data from multiple indicators or timeframes

When a string exceeded 4,096 characters, Pine Script silently truncated it⁴. There was no error or warning. The string simply lost everything beyond the limit, which could produce malformed JSON in webhook alerts, incomplete tooltip text, or missing data in table displays. This silent truncation was especially problematic for automated trading setups where the alert payload needed to contain specific fields for the receiving platform to process correctly.

The New 40,960-Character Limit

With 40,960 characters available, most practical string operations in Pine Script will never approach the ceiling. To put this in perspective, 40,960 characters is roughly equivalent to eight single-spaced pages of text. This is more than enough for even the most detailed webhook payloads, multi-row table contents, or diagnostic log entries.

The increase applies to all string operations in Pine Script, including string literals, concatenation results, str.format() output, and any other operation that produces a string value³.

Impact on Automated Trading

For developers who send structured alert messages to platforms like TradersPost, the expanded string limit is directly useful. A webhook alert that includes portfolio-level instructions, multiple symbol entries, detailed position management parameters, and risk metadata can now fit comfortably within a single alert message. Previously, developers had to carefully budget their character usage or split information across multiple alerts, adding complexity to both the Pine Script code and the receiving system.

Scripts that use Pine Logs for debugging also benefit significantly. The log.info(), log.warning(), and log.error() functions accept formatted strings³, and with the increased limit, developers can log comprehensive state dumps that include all relevant variables, indicator values, and conditions without worrying about truncation.

August 2025: Pine Editor Redesign

Alongside the string length increase, the August 2025 update introduced a major change to the Pine Editor's physical layout within the TradingView interface¹. The editor began transitioning from its traditional horizontal bottom panel to a vertical side panel positioned alongside the chart.

The Old Layout

Since its introduction, the Pine Editor occupied a horizontal panel at the bottom of the TradingView screen, sharing space with the strategy tester, Pine Logs, and other bottom panel tabs. This layout had several drawbacks for code editing. Horizontal screen space was abundant, but vertical space was limited. Scripts with many lines required constant scrolling, and the editor competed for vertical real estate with the chart itself. Resizing the bottom panel to see more code meant shrinking the chart, making it harder to verify that your indicator was rendering correctly.

The Side Panel Layout

The new side panel layout places the editor in a vertical column to the right of the chart. This arrangement provides significantly more vertical space for viewing code while maintaining a usable chart width. For developers with wide monitors or multi-monitor setups, the side panel layout is a substantial improvement because it leverages horizontal screen space that was previously underutilized.

The side panel layout makes it easier to see the relationship between your code and its visual output. You can edit a plot's color, save the script, and immediately see the change on the chart next to the editor without scrolling or resizing panels.

Word Wrap with Alt+Z

The August update also introduced a word wrap toggle for the Pine Editor, activated by pressing Alt+Z on Windows and Linux or Option+Z on macOS¹. When enabled, long lines of code wrap visually within the editor window instead of extending horizontally beyond the visible area.

Word wrap is purely a display feature. It does not change the actual code or insert line breaks. It simply adjusts how long lines are rendered in the editor, making them fully visible without horizontal scrolling. This is particularly useful for scripts that contain long string literals, complex function calls with many parameters, or comments that extend beyond the editor's width.

For Pine Script specifically, word wrap helps when reviewing long input.*() declarations, multi-parameter plot() calls, or str.format() strings. Instead of scrolling right to see the end of a line, the entire statement is visible within the editor panel.

Adapting Your Workflow

The side panel layout may require some initial adjustment, especially if you have used the bottom panel for years. A few practical tips for the transition:

• If your screen resolution is below 1920 pixels wide, the side panel may feel cramped. In this case, the bottom panel layout may still be preferable, and TradingView allows switching between layouts
• Word wrap is off by default. Toggle it on with Alt+Z if you find yourself frequently scrolling horizontally
• The Pine Logs pane and strategy tester remain in the bottom panel area, so you may need to keep a small bottom panel open alongside the side editor for debugging and strategy analysis

December 2025: Flexible Line Wrapping

The December 2025 update addressed one of Pine Script's most confusing syntax rules: the restriction on indentation levels for wrapped lines of code¹. This change made the language more forgiving and aligned its behavior with developer expectations from other programming languages.

How Line Wrapping Worked Before

Pine Script uses indentation to define code structure⁴. Local blocks inside if statements, loops, and functions are indented by four spaces or one tab. To distinguish a continuation line (a wrapped line that is part of the same statement) from a new local block, Pine Script required that continuation lines use indentation that was not a multiple of four spaces.

For example, wrapping a long plot() call required using indentation like two spaces, six spaces, or any other non-multiple-of-four value:

//@version=6
indicator("Old wrapping style")
plot(
  close,
  title = "Close",
  color = color.blue
)

Using two spaces worked. But if a developer habitually used four-space indentation (common in many other languages), the following code would fail to compile:

// This would NOT compile before December 2025
plot(
    close,
    title = "Close",
    color = color.blue
)

The compiler interpreted the four-space indentation as the start of a new local block rather than a continuation of the plot() call, causing a syntax error.

What Changed

The December 2025 update removed the indentation restriction specifically for lines wrapped inside parentheses². This includes function calls, grouped expressions, and function parameter declarations. Within parentheses, wrapped lines can now use any indentation level, including zero spaces, four spaces, eight spaces, or any other value.

After the update, both of the following styles compile without error:

//@version=6
indicator("Line wrapping demo")

// Two-space indentation (always worked)
plot(
  close,
  title = "Close",
  color = color.blue
)

// Four-space indentation (now works inside parentheses)
plot(
    close,
    title = "Close",
    color = color.blue
)

You can even mix indentation levels within the same set of parentheses, though this is not recommended for readability. Each wrapped line within parentheses can independently use any indentation length.

Lines Outside Parentheses

The original restriction still applies to wrapped lines that are not enclosed in parentheses⁴. If you wrap a line using the continuation operator or a binary operator at the end of a line, the continuation must still use non-multiple-of-four indentation. For example:

//@version=6
indicator("Non-parenthesized wrapping")

// This wrapped line is NOT inside parentheses, so it must avoid 4-space multiples
float closeDiff =
  close          // Two-space indent (correct)
  - close[1]     // Two-space indent (correct)

This distinction makes sense because Pine Script needs a way to differentiate between "this indented line continues the previous statement" and "this indented line starts a new local block." Parentheses provide an unambiguous boundary, so the compiler can safely relax the indentation rule within them.

Recommended Style

The Pine Script style guide now documents this updated behavior⁴. For function calls and other parenthesized expressions, the recommended approach is to wrap each argument on its own line with consistent indentation. The closing parenthesis can sit on a separate line aligned with the start of the expression:

//@version=6
indicator("Consistent line wrapping style demo")

int lengthInput = input.int(
    defval = 10,
    title = "Show last",
    minval = 1
)

plot(
    series = close,
    title = "Close",
    color = color.blue,
    linewidth = 3,
    show_last = lengthInput
)

This style is clean, familiar to developers from other languages, and takes full advantage of the December 2025 relaxation. It also works well with the Pine Editor's word wrap feature, as each argument sits on a visually distinct line.

Impact on Existing Code

The change is fully backward compatible². Scripts that already use non-multiple-of-four indentation for wrapped lines will continue to work exactly as before. Only code that previously failed to compile due to four-space indentation inside parentheses will now succeed. If you have old scripts that you restructured to avoid this issue, you can optionally reformat them to use your preferred indentation style.

How These Changes Work Together

Individually, each of these four improvements addresses a specific pain point. Together, they represent a meaningful modernization of the Pine Script development experience.

The unlimited scope count means you can structure your code logically without worrying about compiler limits. The 10x string length increase means your alert payloads, tooltips, and log messages can contain as much detail as you need. The redesigned editor gives you a better physical workspace for writing and reviewing code. And the relaxed line wrapping rules mean you can format your code using the indentation conventions you already know from other languages.

For developers building automated trading systems, these improvements have a direct impact on productivity. A strategy that generates detailed TradingView webhook signals can now use unlimited conditional branches to determine signal parameters, construct large JSON payloads without truncation, be written in a properly formatted editor with word wrap, and use clean four-space indentation throughout.

Automating Pine Script Strategies

These developer experience improvements make it easier than ever to build sophisticated Pine Script strategies. Once your strategy generates reliable signals, the next step is connecting those signals to live order execution.

TradersPost connects TradingView alerts to supported brokers for automated order execution⁵. You can take any strategy built with these 2025 Pine Script improvements and route its signals directly to live or paper trading accounts through webhook automation. The expanded string limits are particularly useful here, as your alert messages can now carry the detailed position management instructions that automated execution platforms need to handle complex order logic.

References

¹ Pine Script Release Notes
² Pine Script v5 to v6 Migration Guide
³ Pine Script v6 Language Reference
⁴ Pine Script User Manual
⁵ TradersPost — Automated Trading Platform