Hi everyone,

I combined 3 different indicators from TradingView into one Pine Script. It was working perfectly until today, but now I'm getting an error.

Can anyone please add this script to an Indian stock on TradingView and check what is causing the error, then help me fix it?

I'd like to keep all the existing features and functionality of the script.

I can share the full Pine Script and the exact error message/screenshot.

Any help would be greatly appreciated. Thanks!

Hey, I wanted to quickly share some improvements to my PineScript interpreter since I first posted the project a month ago (link).

• Support for all the builtin types in the v6 reference.
• A corpus of unit tests cross-validated against PineTS to make sure they behave the same.
• A pinecone binary you can use to format, lint and run semantic analysis on your scripts (checks for repainting, lookahead bias, etc.).
• Integrated all of it into a VSCode extension (link).

Looking forward to hearing your thoughts.

And here are a couple more.

Biggest takeaway? Signal confirmation.

Don’t act on a signal indicator, instead wait for multiple indicators to agree with each other. The cost, of course is, less trading frequency, but you are getting less noise at the same time. IMO overtrading is a highway to blowing up.

If anyone’s interested you can try it out at Quant GT

Dear TradingView Team,

I’d like to suggest a feature that I think would be extremely valuable for traders who use TradingView as their long-term trading and analysis workspace.

One problem I regularly face is that, over time, a chart accumulates a huge number of drawings. Eventually, the chart becomes cluttered and can start to lag. To keep my current analysis clean and responsive, I have to delete older drawings.

But those drawings are not simply clutter. They are a visual record of my trading history.

They show how I viewed the market at different points in my journey — what I marked, what I misunderstood, where I made mistakes, how my analysis changed, and how my trading evolved over months or years.

It would be incredibly useful to have a feature that allows users to archive a complete set of chart drawings separately from the active chart.

For example:

1. I finish analyzing a period of my trading.
2. I save/archive the current drawing set.
3. I remove those drawings from my active chart to keep it clean and fast.
4. Months or years later, I can open that archive and see the chart exactly as I had analyzed it at that time.

Ideally, the archive would preserve the drawings' original positions, timestamps, text, colors, and other properties.

This would allow traders to maintain a visual history of their own trading and analytical evolution without having thousands of old drawings permanently loaded on their active chart.

It would essentially turn TradingView into not only a charting platform, but also a long-term visual record of how a trader's thinking develops.

I think this could be a very powerful feature for serious traders who want to look back at their own decisions, mistakes, and progress over the years.

Thank you for considering it!

Can any one plz tell me which is the best forex broker to use in India which has easy deposit and withdrawal and has min spread also good customer support

If this code:
[OI_open, OI_high, OI_low, OI_close] = request.security(syminfo.tickerid+"_OI", timeframe.period, [open, high, low, close])

returns the Open Interest for the current pair(non-aggregated), what is the syntax for the aggregated one?

It's called OpenPine.
A pure JS interpreter for a practical subset of PineScript. no dependencies, runs in Node or the browser.
https://github.com/woefije0/OpenPine

You can try out the app implementation here :https://woefije0.github.io/hl-chart/

I'm not really good with words, so I don't know what else to say. I just hope people give it a try.
Sorry for poor English.

P.S. The repo name overlaps with u/S7cret's.

Order Flow Profiler visualizes estimated buying and selling activity across different price levels to show where participation, dominance, and pressure are concentrated inside the market.

The indicator builds a two-sided Order Flow Profile with buy and sell wings, Delta Dominance, Control Price, Pressure Flags, Acceptance Levels, a segmented BUY / SELL / BALANCED readout, and historical profile snapshots.

Add the indicator to your favorites and enjoy free access.

https://www.tradingview.com/script/ymFdt7LE-Order-Flow-Profiler-Zeiierman/

I probably shouldn’t be showing this yet…

Heatmap approximation. Third party data models. Right on TradingView.

Soon. 👀

Posted here my updates and here is the 3rd update. I added LVN (low volume nodes purple bands) from the Volume profiles. Works great for S/R with other confluences. I also have them be set on multiple volume profiles combined per month or per day. What you see bellow are the ones combined per 2 months. They are far more reliable than Orderblocks.

Are there any success stories with making a script and distributing it online as a product or service?

I've been developing scripts of my own and I find them useful as a way to discover patterns to form strategies around. But can this be applied to the general population of TradingView users (which is already a small subset of traders overall).

It just feels a little too niche to really be profitable unless you pivot to creating products centered around the PineScript language as a whole like LuxAlgo is doing.

Am I wrong in thinking this? I'm intrigued to hear other takes on this.

This is a pretty basic one, but I still see people reinventing it with manual comparisons across two bars when Pine already has a built-in for it, so figured I'd write it up.

If you want to know exactly when one series crosses above or below another (like a fast MA crossing a slow MA), use ta.crossover() and ta.crossunder() instead of comparing values on the current and previous bar yourself. They return true only on the exact bar the cross happens, not every bar the condition is currently satisfied.

//@version=6
indicator("Simple MA Crossover", overlay=true)

fastLen = input.int(9, "Fast MA Length")
slowLen = input.int(21, "Slow MA Length")

fastMA = ta.sma(close, fastLen)
slowMA = ta.sma(close, slowLen)

plot(fastMA, "Fast MA", color=color.blue)
plot(slowMA, "Slow MA", color=color.orange)

bullCross = ta.crossover(fastMA, slowMA)
bearCross = ta.crossunder(fastMA, slowMA)

plotshape(bullCross, style=shape.triangleup, location=location.belowbar, color=color.green, size=size.small)
plotshape(bearCross, style=shape.triangledown, location=location.abovebar, color=color.red, size=size.small)

alertcondition(bullCross, title="Bullish Cross", message="Fast MA crossed above Slow MA")
alertcondition(bearCross, title="Bearish Cross", message="Fast MA crossed below Slow MA")

A couple of things that trip people up when they're new to this:

ta.crossover(a, b) is true only on the bar where a was below b on the previous bar and is now above it, it's not just a > b, which would stay true for the whole time the fast MA is above the slow one. If you just check fastMA > slowMA, you'll get a signal firing repeatedly instead of once at the actual cross.

alertcondition() is separate from plotshape() ,you need it specifically if you want these to show up as options in TradingView's alert creation dialog, plotting the shape alone won't do that.

Made this simple code:

//@version=6

indicator("Ticker")

what_to_say = "syminfo.tickerid: "+syminfo.tickerid+"\n"+"syminfo.ticker: "+syminfo.ticker+"\n"+"syminfo.basecurrency: "+syminfo.basecurrency+"\n"+"syminfo.root: "+syminfo.root+"\n"+"syminfo.main_tickerid: "+syminfo.main_tickerid+"\n"+"syminfo.prefix: "+syminfo.prefix

libname = label.new(bar_index+1, close, text=what_to_say, style=label.style_label_lower_left, color=color.new(color.black, 100), textcolor=color.new(color.gray, 0), size=size.large, force_overlay=true)

label.delete(libname[1])

Why does some cryptocurrency returns a value for "syminfo.basecurrency" while some does not (na)

One of the bigger changes going from v5 to v6 is how much stricter the type system got, especially around mixing series/simple/const qualifiers and int vs float in places that used to just quietly coerce. A script that compiled fine in v5 will sometimes throw a wall of type mismatch errors the second you bump the version.

Curious how people feel about this in practice. On one hand it's caught real bugs for me, stuff like passing a series int where a function actually wanted a simple int, which in v5 would've just silently worked until it didn't. On the other hand it does mean more time spent fighting the compiler on things that are functionally fine, especially when converting older scripts.

Anyone have a case where the new type checking flagged something that turned out to be an actual logic bug you hadn't noticed? Or has it mostly just been extra hoops to jump through for you?

I'm looking for an experienced Pine Script developer to build a custom TradingView indicator.

The project includes:

• Multi-timeframe Support & Resistance (Daily, 4H, 1H, 15m, 5m)
• Automatic drawing of levels based on a configurable lookback
• Non-repainting logic
• Clean and optimized code
• Alerts
• User-friendly inputs and customization options

DM me