Pine Script Updates 2025-2026

TradingView has shipped twelve Pine Script updates between February 2025 and January 2026, each adding language features, data access improvements, and quality-of-life changes for script developers¹. If you write indicators or strategies in Pine Script, keeping up with these changes is essential because every release unlocks capabilities that were previously impossible or required cumbersome workarounds. This guide walks through every Pine Script update in reverse chronological order so you can quickly find what matters to your workflow.

Whether you are building custom volume analysis tools with the new footprint requests, tapping into real-time bid/ask spreads, or simply enjoying unlimited local scopes, the 2025-2026 cycle has delivered meaningful improvements across the entire language. Below you will find explanations, practical context, and code examples for each monthly release.

January 2026: Footprint Requests

The January 2026 release is the largest single addition to Pine Script since version 6 launched. It introduces first-class support for volume footprint data through three new constructs: the request.footprint() function, the footprint type, and the volume_row type¹.

How It Works

Calling request.footprint() retrieves volume footprint data for each bar on the chart³. The function returns a footprint object that contains aggregated volume metrics and individual price-level rows you can iterate over.

The footprint type exposes high-level accessor functions:

• footprint.buy_volume() - total buying volume for the bar
• footprint.sell_volume() - total selling volume for the bar
• footprint.delta() - net difference between buying and selling volume
• footprint.vah() - Value Area High price
• footprint.val() - Value Area Low price
• footprint.poc() - Point of Control (price level with highest volume)³

Each row within the footprint is a volume_row object, which provides granular detail:

• volume_row.up_price() and volume_row.down_price() - upper and lower price boundaries of the row
• Volume values for buys, sells, and totals at each price level
• Imbalance detection between aggressive buyers and sellers

Example Code

The following script demonstrates a basic footprint request that retrieves volume profile data with customizable tick size and value area percentage:

//@version=6
indicator("Footprint demo", overlay = true)
int numTicksInput = input.int(100, "Ticks per footprint row", minval = 1)
int vaInput = input.int(70, "Value Area percentage", minval = 1)
footprint reqFootprint = request.footprint(numTicksInput, vaInput)

Why It Matters

Volume footprint analysis was previously only available through third-party tools or external data providers. With native Pine Script support, developers can now build custom volume profile indicators, delta divergence strategies, and imbalance detection systems entirely within TradingView. Note that this feature requires a Premium or Ultimate TradingView subscription¹.

December 2025: Updated Line Wrapping

The December update addresses a longstanding source of frustration for Pine Script developers: indentation rules inside wrapped lines.

What Changed

Previously, when you wrapped a long line of code inside parentheses, the continuation lines could not use indentation that was a multiple of four spaces. This caused unexpected compilation errors, especially for developers who use four-space indentation as their standard. The December update removes this restriction for lines wrapped inside parentheses¹.

Before December 2025: continuation lines inside parentheses using 4, 8, or 12 spaces of indentation would trigger a compilation error.

After December 2025: any indentation level works inside parentheses, including multiples of four spaces.

Lines that are not wrapped inside parentheses still follow the original rule and must avoid multiples of four for continuation indentation.

Why It Matters

This is a small but welcome quality-of-life improvement. Developers who use four-space indentation by convention no longer need to remember a special exception for wrapped lines. It also reduces confusion for developers migrating from other languages where four-space indentation is standard.

November 2025: syminfo.isin

November introduced the syminfo.isin variable, which returns the 12-character International Securities Identification Number (ISIN) for the current symbol¹.

What It Does

The ISIN is a globally unique identifier assigned to securities by national numbering agencies. Unlike ticker symbols, which vary between exchanges (for example, "AAPL" on NASDAQ versus a different identifier on a foreign exchange), the ISIN remains consistent across all markets where a security is listed.

If no ISIN is available for the current symbol, syminfo.isin returns an empty string³.

Example Usage

//@version=6
indicator("ISIN Display")
if barstate.islast
    label.new(bar_index, high, "ISIN: " + syminfo.isin, style = label.style_label_down)

Why It Matters

Scripts that operate across multiple exchanges or need to match symbols between data sources can now use ISIN as a reliable cross-reference key. This is particularly useful for portfolio analysis scripts, cross-listed security detection, and compliance-related tools.

October 2025: timeframe_bars_back Parameter

The October release added a new timeframe_bars_back parameter to the time() and time_close() functions¹.

What Changed

Previously, the bars_back parameter in time() and time_close() offset by bars on the chart's current timeframe. The new timeframe_bars_back parameter offsets on the specified timeframe instead, regardless of what timeframe the chart is displaying³.

You can also combine timeframe_bars_back with the existing bars_back parameter for complex timestamp calculations that reference multiple timeframe contexts.

Example Usage

//@version=6
indicator("Timeframe Offset Demo")
// Get the opening time of 3 daily bars ago, regardless of chart timeframe
dailyTimeThreeBarsBack = time("D", timeframe_bars_back = 3)
plot(dailyTimeThreeBarsBack)

Why It Matters

Multi-timeframe strategies often need to reference timestamps from higher timeframes. Before this update, calculating those offsets required workarounds involving request.security() calls. The new parameter simplifies the logic and makes Pine Script strategy automation cleaner for multi-timeframe systems.

September 2025: Plot Linestyles

September brought a new linestyle parameter to the plot() function, giving developers control over how plotted lines are rendered¹.

Available Styles

The linestyle parameter accepts three values:

• plot.linestyle_solid - continuous solid line (default behavior)
• plot.linestyle_dashed - dashed line pattern
• plot.linestyle_dotted - dotted line pattern³

This parameter only applies when the plot style is set to a line-based display. It has no effect on histogram, column, area, or other non-line plot styles.

Example Usage

//@version=6
indicator("Linestyle Demo", overlay = true)
plot(ta.sma(close, 20), "SMA 20", color = color.blue, linestyle = plot.linestyle_solid)
plot(ta.sma(close, 50), "SMA 50", color = color.red, linestyle = plot.linestyle_dashed)
plot(ta.sma(close, 200), "SMA 200", color = color.gray, linestyle = plot.linestyle_dotted)

Why It Matters

Before this update, all plotted lines were solid. The only way to differentiate multiple lines was through color. Dashed and dotted styles let developers visually distinguish support/resistance levels, signal thresholds, and reference lines without consuming additional colors, making indicators easier to read at a glance.

August 2025: Longer Strings and Pine Editor Improvements

The August release delivered two significant improvements: a 10x increase in maximum string length and Pine Editor usability enhancements.

String Limit Increase

The maximum string length in Pine Script increased from 4,096 to 40,960 characters¹. This is a substantial expansion that removes a common bottleneck for scripts that build large text outputs, generate detailed tables, or construct complex JSON payloads for webhook alerts.

Pine Editor Changes

TradingView began moving the Pine Editor from its traditional bottom panel location to a side panel layout¹. This change gives developers more vertical space for code editing while keeping the chart visible. The update also introduced a word wrap toggle accessible via the Alt+Z (Windows/Linux) or Option+Z (macOS) keyboard shortcut.

Why It Matters

The string limit increase is particularly relevant for automated trading. Scripts that generate structured alert messages for platforms like TradersPost can now include far more detail in their webhook payloads⁵, such as multi-symbol portfolio instructions or detailed position management data. The editor improvements make daily development more comfortable during extended coding sessions.

July 2025: Active Inputs and syminfo.current_contract

July brought two additions: conditional input controls and a new symbol information variable for futures traders.

Active Inputs

All input*() functions now accept a new active parameter¹. When set to false, the input appears grayed out in the settings panel and cannot be changed by the user³. This enables conditional input dependencies where one setting controls whether another is available.

//@version=6
indicator("Active Input Demo")
bool useFilter = input.bool(true, "Enable Filter")
int filterLength = input.int(14, "Filter Length", active = useFilter)
// filterLength input is grayed out when useFilter is false

syminfo.current_contract

The new syminfo.current_contract variable returns the ticker identifier of the current front-month contract when viewing a continuous futures chart¹. This is valuable for scripts that need to determine the active futures contract for order routing or display purposes.

Why It Matters

Active inputs improve the user experience of published scripts by reducing confusion. Instead of showing irrelevant settings, developers can hide or disable inputs based on other selections. The syminfo.current_contract variable solves a practical problem for futures automation, where knowing the exact contract ticker is essential for placing orders through external platforms.

June 2025: Library Constant Exports

June added the ability for Pine Script libraries to export user-defined constant variables, expanding what shared code can provide.

How It Works

Library authors can now define and export constant values using the export and const keywords together¹. Exported constants must be one of the following types: int, float, bool, color, or string⁴.

//@version=6
library("MathConstants")
export const float SILVER_RATIO = 1.0 + math.sqrt(2)
export const float GOLDEN_RATIO = 1.618033988749895
export const int MAX_LOOKBACK = 500

Why It Matters

Before this update, libraries could only export functions. Sharing commonly used constants required wrapping them in getter functions, which added unnecessary overhead and cluttered the API. Direct constant exports make library code cleaner and allow the Pine Script community to build shared configuration packages for common trading parameters, ratio tables, and threshold values.

May 2025: time_close Improvements

May focused on fixing a data availability gap for non-standard chart types.

What Changed

The time_close variable and time_close() function received improvements specifically for tick-based and price-based chart types, including Renko, line break, Kagi, point & figure, and range charts¹. Previously, these chart types returned na for time_close on realtime bars because the closing timestamp was not determined until the bar actually closed.

After this update, the closing timestamp becomes available immediately after a bar closes on these chart types, eliminating the na gap that previously affected realtime analysis.

Why It Matters

Strategies running on Renko or range charts can now accurately timestamp bar closures in real time. This is important for time-based trade management logic, session filtering, and logging. Developers who build time-based trade management in Pine Script no longer need to account for missing timestamp data on these alternative chart types.

April 2025: PercentageLTP Box Sizing

April introduced a new box sizing style for non-standard chart types.

What Changed

The ticker.renko(), ticker.pointfigure(), and ticker.kagi() functions now accept a new "PercentageLTP" style option¹. When selected, box sizes are calculated as a percentage of the last trading price rather than using a fixed absolute value³.

Why It Matters

Percentage-based box sizing automatically adapts to the price level of the instrument. A Renko chart for a $10 stock and a $500 stock can use the same percentage setting and produce proportionally appropriate box sizes. This eliminates the need to manually adjust box sizes when switching between instruments or when an instrument's price changes significantly over time.

March 2025: Dynamic For Loops and box.set_xloc()

The March release changed fundamental loop behavior and added a missing setter function.

Dynamic For Loop Boundaries

The for loop's to_num boundary is now evaluated dynamically before every iteration¹. Previously, the boundary value was captured once at loop entry and remained fixed throughout execution. This means that modifying the boundary variable inside the loop body now affects subsequent iterations.

//@version=6
indicator("Dynamic Loop Demo")
int limit = 5
int count = 0
for i = 0 to limit
    count += 1
    if i == 2
        limit := 3  // Now actually shortens the loop
// count will reflect the dynamic boundary change

box.set_xloc()

A new box.set_xloc() setter function was added, matching the existing line.set_xloc() and label.set_xloc() functions³. This setter allows you to change the x-axis location reference of a box after creation.

Why It Matters

Dynamic loop boundaries enable more flexible algorithms where the iteration range depends on conditions discovered during execution. This is useful for adaptive analysis windows, dynamic support/resistance level scanning, and other patterns where the search space changes based on intermediate results. The box.set_xloc() addition fills a gap in the drawing API, giving boxes the same post-creation flexibility that lines and labels already had.

February 2025: Unlimited Scopes and Bid/Ask Variables

The February 2025 release kicked off the year with two impactful changes: the removal of scope limits and new market microstructure data.

Unlimited Local Scopes

Pine Script previously enforced a hard limit of 550 local scopes per script². A "scope" is created by each if block, for loop, while loop, switch statement, or function call. Complex strategies with many conditional branches and nested loops would hit this ceiling and fail to compile.

The February update removed this limit entirely¹. Scripts can now contain as many local scopes as needed without encountering compilation errors.

Bid and Ask Variables

Two new built-in variables, bid and ask, provide access to real-time best bid and ask prices¹. These variables are only available on the "1T" (one tick) timeframe. On all other timeframes, they return na³.

//@version=6
indicator("Spread Monitor", overlay = true)
float spread = ask - bid
plot(spread, "Bid-Ask Spread", color = color.orange)
// Only produces values on the 1T timeframe

Why It Matters

Removing the scope limit is a significant improvement for advanced strategy developers. Complex multi-asset scanners, elaborate risk management systems, and strategies with many conditional paths no longer need artificial restructuring to stay under the 550-scope ceiling. The bid and ask variables open the door to spread analysis, market microstructure studies, and execution quality monitoring directly within Pine Script. While limited to tick charts, this data was previously unavailable in any form within the language.

Summary of All Updates

Here is a quick reference table of every Pine Script update from this period:

• January 2026: Footprint requests with request.footprint(), footprint type, and volume_row type for volume profile analysis
• December 2025: Relaxed line wrapping indentation rules inside parentheses
• November 2025: syminfo.isin variable for global security identification
• October 2025: timeframe_bars_back parameter for time() and time_close() functions
• September 2025: Plot linestyle parameter with solid, dashed, and dotted options
• August 2025: 10x string length increase to 40,960 characters and Pine Editor side panel
• July 2025: Active input parameter and syminfo.current_contract for continuous futures
• June 2025: Library constant exports with export const syntax
• May 2025: time_close fixes for Renko, Kagi, line break, point and figure, and range charts
• April 2025: PercentageLTP box sizing for Renko, point and figure, and Kagi charts
• March 2025: Dynamic for loop boundaries and box.set_xloc() setter
• February 2025: Unlimited local scopes and bid/ask variables on tick charts

Automating Your Updated Pine Script Strategies

Each of these Pine Script updates creates new possibilities for trading automation. The footprint data enables volume-based signal generation. Dynamic loop boundaries allow adaptive algorithms. Active inputs let you build more user-friendly strategy configurations. And the expanded string limits make it easier to construct detailed webhook alert messages.

If you are building Pine Script strategies that generate buy and sell signals, TradersPost connects your TradingView alerts directly to supported brokers for automated order execution⁵. You can take any strategy that uses these new Pine Script features and route its signals to live or paper trading accounts through TradingView webhook automation.

The combination of Pine Script's growing capabilities and a platform like TradersPost means you can go from a new indicator idea to a fully automated trading system without writing broker API code. Whether you are analyzing footprint deltas, monitoring bid-ask spreads on tick charts, or running multi-timeframe strategies with the new timeframe offset functions, the path from signal to execution has never been more straightforward.

For more on getting started with Pine Script development and automation, explore these related guides:

• What is Pine Script - foundational overview of the language
• Pine Script v6: What's New - the base version these updates build upon
• Pine Script Strategy Automation Guide - converting indicators to automated strategies
• How to Avoid Repainting in Pine Script - ensuring signal reliability
• Pine Script vs Python for Trading - choosing the right tool for your needs

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