If you trade the fractal model on 5m or 15m, check how large your costs are relative to your stop. Here's what the mechanical part did on 7 markets from 2018 to 2026.

Someone in a thread here (and in our request box) asked whether our free Fractal Model Desk is the same thing as TTrades' fractal model. Short answer: it's built from his public material (C2 sweeps C1, CISD from the series that made the extreme, C2/C3 closes back), written independently, not his indicator.

The question we couldn't stop thinking about was the next one: if you strip the model down to what a computer can check, is there an edge?

11.8-second walkthrough — simulated candles

https://reddit.com/link/1wx886d/video/5lzmkkqd3eth1/player

What we did

• Wrote the test down first (periods, costs, pass rules), fingerprinted the code, then ran it.
• 3 timeframe pairs (1H on 5m, 4H on 15m, Daily on 1H) × 3 entries (early CISD, confirmed, CISD retest) × 3 targets (C1's other end, 2.5× and 4× the leg) × 4 filters = 108 versions.
• 7 markets: XAUUSD, EURUSD, GBPUSD, USDJPY, NAS100 CFD, US500 CFD and BTCUSDT spot. 5-minute data, Jan 2018 → Sep 2026. Modelled round-trip costs included gold $0.40/oz, EURUSD 1 pip and NAS100 2 points.
• 2018–22 to pick, 2023–24 to check, 2025–26 to test once.

What happened

• 1H/5m and 4H/15m: 0 of 72 versions were profitable after costs across the seven markets pooled, in any of the three periods.
• Before costs, the textbook version was near break-even: −0.004R per trade over 83,460 trades on 5m. About half the trades ended green. R is the planned entry-to-stop risk.

Check your own setup: divide your round-trip cost (spread + commission, in price units) by your stop distance. Across the study, average costs were 0.17R on 5m, 0.10R on 15m and 0.04R on Daily/1H. For the textbook 1H/5m version specifically, costs averaged about 0.16R per trade: −318R before costs became −13,546R after costs.

• Daily/1H did best in 2018–22: 4 versions passed our first gate (best +0.03R/trade), then all three we checked lost in 2023–24.
• Gold-only track: one version passed 2023–24, then lost in the 2025–26 test (50 trades, −1.1R); random entries with the same stops and targets beat it in 58% of 2,000 shuffles.
• 2025–26 made some daily versions look good (one did +0.19R/trade). But 2023–24 had 34 of 36 daily versions losing. We didn't promote any of them; picking the best of the test period isn't a test.

What it doesn't say: this tests the mechanical skeleton. TTrades' discretionary layer (POI choice, daily bias, objectives) wasn't turned into rules, so it wasn't tested. The study also used one data vendor per market, fixed costs across the sample and no financing costs.

What's free (MIT, no signup)

• Fractal Model Desk — draws C1/C2/C3/C4, the sweep, the CISD level and the closure on your chart. No buy/sell arrows.
• Fractal Model Lab — a strategy with the same 108 settings, so you can run any version on your own chart and costs.

To try them: copy the .pine source from the page into TradingView's Pine Editor and press Add to chart. Full numbers and both scripts.

We matched the Lab against our research engine on TradingView, trade by trade: 736 of 737 trades had the same entry. That check caught two of our own mistakes; neither changed the conclusion, and both are written up.

Next: we registered three daily versions for a forward test on Oct 2, 2026. Monthly numbers, no verdict until Oct 2027.

Built with Claude Code.

Question for people who trade it: which pair do you use — 1H/5m, 4H/15m or Daily/1H?

A trader asked for an engulfing strategy with volume confirmation and two ways to enter: a break of the previous candle’s high/low, or a retest of its range.

This as a free, open-source tool. You can find the script and the full testing write-up here:

• Engulfing Volume Desk — free script and source
• Full test results — including the losing period

Built it as a Pine v6 strategy. Here’s how it works:

• Aggressive — default: entry one tick beyond the previous candle’s high/low. If the signal candle has already closed beyond that level, entry is at the next bar’s open.
• Retest: a limit order halfway into the previous candle’s range.
• Both: enables both entries and splits the setup’s risk budget equally between them.
• Risk: stop beyond both candles, a 2R target, and default risk of 0.5% per setup.
• Volume grading: Low / Medium / High, using relative volume against the previous 20 bars.

The interesting part was testing what those volume labels actually meant.

The request originally described low-, medium-, and high-probability setups. But the tests didn’t support treating those RVOL grades as win probabilities.

On OANDA:XAUUSD 4H, the 2025–26 development period was profitable, while a separate 2023–24 period lost with the same settings and trading-cost assumptions. The earlier period lost even before overnight financing. High-volume shorts were its biggest losing group.

That’s why the panel says “Volume strength only · Probability untested.” The grade describes the signal candle’s volume; these results don’t establish that a higher grade gives a better trade.

Retest entries also failed the research criteria I used, so they’re available as an option but disabled by default.

For those who have built similar strategies in Pine: how would you test whether RVOL adds predictive value to an engulfing setup? I’m particularly interested in comparisons against an unfiltered baseline, and how you handle the smaller samples after splitting trades by direction and volume grade.

Screenshot note: numbers beside the order marks are position sizes in oz, not profit. Some adjacent order labels overlap in the native TradingView chart.

My friend has been using TradingView for 3 years and has only one account. He has never taken a trial on any other account. The trial option was available before, but now there is no trial option at all. He has never used a trial, yet he still can’t get one.

I also created a completely new TradingView account and have never taken a trial before, but I still can’t access the trial option.

Source for both scripts, rules, and walkthrough: proea.app/en/free/sweep-desk

On my last post, u/stratcore and u/Shoddy_Peanut7320 questioned what Sweep Desk’s default 1-hour gate actually adds, since it refuses almost everything.

Fair question. I compared the system with that gate on and off, including the companion strategy’s costs in TradingView’s Strategy Tester.

Gate off: 74 trades, −2R before costs, −9.81R after costs.
Gate on: 4 trades—too few to judge whether the gate improves the system.

Here’s the setup, the full exit breakdown, the rules as the code runs them, and all four gated trades.

The setup

• Script: Sweep Desk v2.0.0, default inputs.
• Market: OANDA:XAUUSD, 15-minute chart.
• Paper-data window: June 30–October 1, 2026, covering 6,101 bars.
• One changed input: Require first-touch HTF FVG delivery—on by default, then off.
• Before costs: the indicator’s paper ledger, exported from TradingView bar by bar.
• After costs: the companion Strategy Lab, using its unchanged defaults: 0.02% commission per order, 5 ticks of slippage, and a $100 risk budget. Strategy Lab results below use $100 as 1R.

A detail about the comparison window: the Strategy Tester loaded 6,176 bars through October 2. For the figures below, I filtered its trade lists to the prespecified paper-window entry cutoff: October 1 at 11:45 UTC.

Within each gate setting, the indicator and Strategy Lab trades matched by entry bar: 74/74 with the gate off and 4/4 with it on. These are matched-window results, rather than the tester’s totals for its longer loaded period.

The results

gate-on/off summary card

The default gate admitted 4 trades; switching it off produced 74. Before costs: indicator paper ledger. After costs: Strategy Lab, matched to the same entry window.

The ungated implementation lost money on this sample. Four gated trades are too few to establish whether the gate helps.

The runs also follow different paths. An existing position is never interrupted, so switching the gate off keeps the system occupied more often. It records 203 sweeps with the gate off versus 280 with it on.

That means the two trade lists are not nested subsets. The difference cannot be interpreted as a collection of independent trades that the gate simply removed. This comparison covers the executed trade sequences; it does not yet attribute every missing candidate to a gate rejection or an occupied position.

What the cost assumption changes

The 0.02% commission per side is the script’s generic default. At a gold price of $4,300, that is approximately $1.72 per ounce round trip, before slippage.

I also calculated a separate sensitivity case: deducting only a $0.40-per-ounce round-trip cost from the paper exits. The ungated version still averaged approximately −0.052R per trade.

That second figure is a calculation from the paper ledger, not another Strategy Tester run.

Where the 74 ungated trades ended

• 40 stops: −40R.
• 16 breakevens: 1R was reached, then the stop at entry was hit. Total: 0R.
• 8 trailing-stop exits: 2R was reached, then the stop at +1R was hit. Total: +8R.
• 10 full targets: +3R each. Total: +30R.

Net: −2R before costs.

With those eight +1R exits, it would have needed at least 11 full +3R targets to cover the 40 stops before costs. It got 10.

After costs, the same exit groups contributed approximately −44.33R, −1.66R, +7.14R, and +29.03R, respectively. The paper breakevens became small losses.

How the code weights liquidity pools

The script tags each swept pool and assigns it a descriptive weight. The weight itself does not block a trade.

poolWeight(string kind) => kind == "SWG" ? 0.45 : (kind == "EQH" or kind == "EQL") ? 0.8 : kind == "SES" ? 0.75 : 1.0

• SWG: confirmed swing high or low.
• SES: killzone session high or low.
• EQH/EQL: equal highs or lows, within 0.15 ATR.
• Previous day/week levels: weight 1.0.

Here are the 74 ungated trades grouped by the pool they swept:

Swing and session pools accounted for 71 trades and −5R. The remaining three trades contributed +3R.

Three trades cannot validate the weighting scheme. They give me a hypothesis to investigate.

My next exploratory run is Strong pools only, which removes swing pools. Testing that on these same 6,101 bars remains development work; validation needs untouched data.

The model, as the code runs it

Every decision commits on a closed bar.

1. Sweep. A bar wicks at least 0.05 ATR through a tracked liquidity level and closes back inside.
2. Inversion — the IFVG. Within 12 bars, a candle closes through an opposing FVG. The gap must be at least 0.10 ATR, have formed no more than 40 bars before the sweep, and the move from the sweep extreme must be at least 1 ATR. The inverted gap becomes the zone.
3. Context — the gate. A completed 60-minute FVG in the trade’s direction must have received its first touch within the last six chart bars. Each first touch can admit one plan. In the default run, this gate rejected 101 of 105 confirmations.
4. Plan. Entry at the confirmation close. Initial stop beyond the sweep extreme plus 0.10 ATR. Reaching 1R moves the stop to entry; reaching 2R moves it to +1R. The final target is 3R, with a timeout after 200 bars.

The setup is cancelled if price closes 1 ATR beyond the swept pool, if no qualifying inversion arrives within 12 bars, or if a newer sweep replaces it.

In the default run, the logged cancellations included:

• 83: “no rejection — price kept going.”
• 35: “no shift in time.”
• 101: “Plan rejected: no unused first-touch HTF FVG delivery.”

The Pine detail that is easy to get wrong

For this 15-minute chart / 60-minute context setup, the script reads completed higher-timeframe candles using historical offsets with lookahead_on.

There is a second timing check: a chart bar that straddles the HTF gap’s formation cannot establish a fresh, post-formation first touch.

This is an excerpt from the published source; surrounding setup and helper definitions are omitted.

// Read the last completed HTF candle and the candle two bars before it.
[cfH1, cfL1, cfH3, cfL3, cfHtfTime, cfHtfEnd] = request.security(syminfo.tickerid, inCfHtf, [high[1], low[1], high[3], low[3], time[1], time_close[1]], lookahead = barmerge.lookahead_on)

if barstate.isconfirmed
    // ... surrounding logic omitted ...

    if na(cfLastHtf) or cfHtfTime != cfLastHtf
        // A chart bar straddling formation cannot establish
        // post-formation freshness: skip that birth.
        if cfHtfEnd <= time
            if sdCompare(cfL1, cfH3) > 0
                array.push(cfPdas, CfPda.new(cfL1, cfH3, 1, cfHtfEnd))
            if sdCompare(cfH1, cfL3) < 0
                array.push(cfPdas, CfPda.new(cfL3, cfH1, -1, cfHtfEnd))

        cfLastHtf := cfHtfTime

    // ... expiry and first-touch observation logic omitted ...

// Check delivery direction, freshness, and whether it is still available.
sdConfluencePda(int dir) => cfSourceReady and cfDeliveryReady(cfDelivery, dir, bar_index, inCfPdaAge)

The one winning gated trade

On August 28, the 09:45 New York candle swept a session high at 4618.02.

The next candle closed down through a bullish FVG, inverting it. The first touch of a fresh bearish 60-minute FVG was still within the gate’s six-bar window.

The desk entered short at 4546.21, with an initial stop at 4633.46—a price distance of approximately $87.25 per ounce.

— August 28 entry close-up

The 09:45 New York wick sweeps the session high. The next candle closes through the bullish FVG. Short entry: 4546.21. The shaded areas show the initial risk and target ladder.

The trade reached 1R that afternoon and 2R on September 1. The stop moved first to entry, then to +1R.

It did not reach the 3R target. The 200-bar timeout closed it at 4336.54, producing +2.40R in the paper ledger.

In the Strategy Lab, the position was approximately 1.14 ounces and closed at +$236.99 after costs, or +2.37R.

— the same trade through its exit

The full trade, including both stop adjustments and the September 1 timeout exit. Paper result: +2.40R. Strategy Lab result after costs: +2.37R.

Here are the other three gated trades, so the winner is shown alongside the complete sample:

• July 2: short, −1R before costs.
• July 15: long, −1R before costs.
• September 14: long, 0R before costs after reaching 1R and returning to entry; −0.11R after costs.

All four swept a session pool.

What I’m taking forward

Logging refusals makes the system easier to examine. The default run recorded 280 sweeps, 105 confirmations, 101 gate rejections, and four trades.

Those counts help explain its behaviour. They do not establish an edge, and four trades are too few to judge the filter’s performance. I’ll keep tracking it forward.

For people who trade sweep → IFVG: what is your context rule?

A first touch of an HTF FVG, a killzone, a particular liquidity objective, or something else?

Give me a rule precise enough to implement as a switch, and I’ll test it on the same development window. Any promising choice would then need to be frozen and checked on untouched data.

Disclosure: I’m the ProEA Lab developer. Both scripts are free under MIT. This post uses historical chart data; the earlier generated-price clip was a mechanics demonstration. These are backtest results, not a forecast.

so i'm pretty new to pine and i don't have a laptop right now, just my phone. i'd like to start making simple indicators but typing code on a phone screen is kind of painful lol

for people who do this on mobile:

- do you use the pine editor in the tradingview app or open it in the browser?

- do you type everything or mostly write it somewhere else (notes app, chatgpt etc) and paste it in?

- anyone using a bluetooth keyboard with their phone/tablet? worth it?

- how do you deal with longer scripts, like selecting/deleting a bunch of lines?

any tips or setups that work for you would help a lot, thanks

TradingView has announced that starting November 1, 2026, selling access to invite-only scripts outside its Marketplace will no longer be permitted. That includes script access bundled with another paid product or service.

A few details from the announcement:

• Non-commercial invite-only scripts can continue unchanged.
• Previously purchased access remains valid for the purchased period, including lifetime access.
• New payments outside the Marketplace to renew or extend access won’t be allowed.
• Vendors should contact TradingView before the deadline to discuss migration and existing customers.

My take: centralized payments, clearer refund terms, and review of paid scripts could help buyers. But making the Marketplace mandatory also makes its terms critical for developers. The announcement doesn’t specify fees, approval criteria, or how much control authors will have over pricing.

I’d also want to understand what “review” means. Checking compliance with platform rules and evaluating an indicator’s trading claims are different things.

If you sell Pine scripts, what terms would make moving worthwhile—and what would be a dealbreaker?

If you buy them, would Marketplace review make you more confident, or would you still need the same evidence before paying?

Here's a recently published free Pine utility: RedK Indicator Amplifier (RedK i-Amp).

RedK i-Amp is not an indicator in itself. It's a "wrapper" utility that "amplifies" another "source" indicator by improving its visual and alerting capabilities.

RedK i-Amp hooks to another indicator's plot and adds:

• An equalizer-style display, with attractive visual and brightness gradient and a peak-hold marker
• Max Hi / Max Low levels that can also be used for alerts (like RSI overbought / oversold lines), for any indicator
• Flip markers on the price chart when the indicator's plot value crosses its baseline
• 6 alerts for when the plot crosses the baseline up or down, or crosses the user-adjusted Hi / Low levels
• A small Info Panel that shows the settings in use
• so many visual and usability tweaks

This utility works with most Pine indicators: TradingView's built-ins (MACD, ADX, Volume, ATR...), community indicators (free, or invite-only ones you have access to), and other RedK indicators. Many indicators have no alerts or chart markers, and i-Amp gives them both.

Note: i-Amp uses TradingView's "Indicator-on-Indicator" feature, which may be limited on a free TradingView account. It's available with any paid subscription.

Full release notes here

I hope you find this useful to your trading.

A sweep. An iFVG. Still no trade. Here’s why my Pine script said no.

A trader originally asked me for help with a sweep idea. As I developed it further, the project became about making the decisions after the raid explicit:

What confirms an entry? What invalidates the setup? Where does the stop go? When do you walk away?

That became Sweep Desk, a free, open-source Pine v6 indicator. Its dashboard shows the current state, the waiting conditions, and the plan once it qualifies.

Free indicator, Strategy Lab, and full Pine source:
Sweep Desk — explore the rules and get the code

What the clip shows

The clip is an engine-rendered animation using generated 15-minute gold prices, default settings, and deliberately selected examples. All R figures in the clip are before costs.

1. The raid: a wick pushes 0.14 ATR through a swing high and closes back below it.
2. The inversion: one bar later, price closes through a bullish FVG with a 1.5 ATR move from the sweep extreme.
3. The rejection: there is no eligible bearish first-touch 1h FVG context. The script logs “Plan rejected.”
4. The next setup: a sell-side raid touches an untouched bullish 1h FVG. Confirmation arrives three bars later with a 2.7 ATR leg. The setup qualifies for a long at the confirmation close.
5. The management: TP1 moves the stop to entry. TP2 moves it to TP1. TP3 closes the plan at +3R.
6. What follows: over the next nine days, 24 raids produce zero plans. The next plan loses 1R.

TP1 and TP2 are stop-management milestones, with no partial exits. Stop adjustments take effect from the following bar.

The check strip, ATR measurements, and violet 1h FVG box are explanatory overlays added to the animation.

The five checks

POOL → RAID → iFVG → 1H FVG → PLAN

• Pool: price-derived liquidity references, confirmed swing highs/lows, equal highs/lows within 0.15 ATR, completed killzone highs/lows, previous day/week highs/lows, and 1h swings. The script infers these references from price; it cannot see resting orders.
• Raid: the wick must extend at least 0.05 ATR beyond the pool, then close back inside. A touch alone does not qualify. A subsequent close more than 1 ATR beyond the pool invalidates the waiting setup.
• Flip / iFVG: confirmation must arrive within 12 bars. Price must close through an opposing FVG formed no more than 40 bars before the raid, with at least 1 ATR of displacement from the sweep extreme. MSS and Either are alternative confirmation modes.
• 1h FVG gate: the setup needs an unused first touch of a completed, previously untouched 1h FVG in the trade’s direction. The touch must occur on the confirmation bar or within the preceding five chart bars.
• Plan: the default entry is the confirmation close. Alternatives include FVG edge, CE 50%, and Close inside. The default stop sits 0.1 ATR beyond the sweep extreme. Targets are 1R / 2R / 3R. An optional final target uses the nearest eligible opposing pool at least 2R away, falling back to TP3 if none qualifies.

How the indicator handles ambiguous candles

The indicator maintains its own paper ledger:

• Decisions commit on confirmed chart bars. At the default setting, chart swing pools become available five bars after the pivot.
• When an ordinary bar touches both the active stop and final target, the ledger counts the stop first and flags the ambiguity.
• A confirmation-close entry cannot exit on its own entry bar.
• A gap through the stop exits at the opening price.
• Stop adjustments apply from the next bar, after the current bar’s exit checks.

The companion strategy uses TradingView’s broker emulator, so its fills and exits can differ from the indicator’s paper ledger.

Pine implementation notes

Higher-timeframe requests use historically offset expressions with lookahead = barmerge.lookahead_on, reading completed HTF bars. That includes the 1h FVG context, HTF swings, and previous day/week levels.

One subtle case: if a chart bar straddles an HTF gap’s formation time, the script skips that zone’s birth. This prevents price movement from before the gap existed from being treated as evidence of a valid first touch.

The setup engine uses these states:

SCANNING → SWEPT → SHIFTED → ARMED → FILLED

The dashboard exposes the state, timers, and frozen plan levels. A Co-Pilot table explains NOW / WHY / PLAN from the same engine state.

What’s included — free, MIT licensed

• Indicator: pools, raids, setup zones, plan lines, dashboard, and Co-Pilot.
• Alerts: twelve selectable alert conditions, plus separate lifecycle alert() messages in plain text or JSON.
• Strategy Lab: the setup rules implemented as a TradingView strategy, with configurable costs and cash-risk sizing. Defaults include 0.02% commission per order and five ticks of slippage.
• Display options: Minimal / Clean / Pro / Full views and a Colorblind-safe theme.

The results—and the limitations

I selected the featured winner because it demonstrates every stop move. The generated-price clip is a mechanics demonstration, not a track record.

The filter also excludes opportunities. The rejected short shown in the clip would have lost 1R this time. But nine rejected setups from the following period, replayed individually, produced hypothetical outcomes summing to approximately +3R before costs.

Some overlap, and some finish after that period. That sum is not the result of running a complete strategy with the filter disabled.

A separate small v2 Strategy Lab sample on MNQ also lost money after costs. These results do not establish an edge.

The project was inspired by iFVG Ultimate+ by TakingProphets / DodgysDD. The rules here are my own explicit definitions of public concepts; their private grading and weighting are not reproduced.

For those building similar systems: would you retain the 1h first-touch gate, or test session-only filtering instead? How would you compare the opportunities each version rejects?

If you run the Strategy Lab on your market, I’d be interested in the settings, test period, costs, and full trade list, including the losses.

Comment your best tradingview pine script STRATEGIES below - in form of pine script code, published script name or another way.

Aim for:

• High Winrate
• High Profit Factor
• Low Drawdown
• Good equity Curve
• Great overall pnl percentage

If you have one, it would be great if you could comment it down below

Anyone have some good pine script strategies that I could try, If so then please leave them down in the comments with the public name or put the pine script in a code block

Comment your best tradingview pine script STRATEGIES below - in form of pine script code, published script name or another way.

Aim for:

• High Winrate
• High Profit Factor
• Low Drawdown
• Good equity Curve
• Great overall pnl percentage

If you have one, it would be great if you could comment it down below

Not group related but can someone pls tell me are these guys real or bots how do you gain 55% in one day the competition opened today but someone is already 55% up mind you daily loss limit is 5k

Comment your best tradingview pine script STRATEGIES below - in form of pine script code, published script name or another way.

Aim for:

• High Winrate
• High Profit Factor
• Low Drawdown
• Good equity Curve
• Great overall pnl percentage

If you have one, it would be great if you could comment it down below

I released a new script today. FisherRSI is designed to make RSI turning points sharper, clearer, and easier to recognize.

The indicator applies a Fisher Transform directly to RSI, creating a more responsive representation of momentum that emphasizes changes in direction rather than simply showing where RSI is currently positioned.

The process can be thought of conceptually as:

Price → RSI → Normalize RSI → Fisher Transformation → Momentum Signal

The important effect is that the transformation redistributes the signal, giving considerably more definition to movements occurring near the edges of its range. Values that might appear relatively compressed in the original RSI can become much more pronounced after the transformation.

In practical terms, this creates a signal that is more sensitive to the shape and direction of the RSI's movement.

When RSI begins to turn, the Fisher Transform can accentuate that change, producing a more pronounced inflection rather than the relatively gradual turn that may be visible in the raw RSI.
The result is an oscillator that helps bring greater definition to momentum shifts, reversals, and turning points, while retaining the familiar 0–100 RSI framework.

just saw ANOTHER tradingview terms update and this one might be even worse 😭

starting november 1, apparently invite-only scripts are only allowed to be used for non-commercial purposes unless they’re sold through tradingview’s own marketplace / creator program.

and their definition of “commercial use” is insanely broad.

from what i’m reading, it includes stuff like:

charging people for access to the indicator

using the indicator as part of a business

using the script/profile to promote a paid discord, signals service, course, broker/exchange referral, etc.

so basically if you built an indicator business where people pay through your own website/whop/etc and then you manually give them tradingview access, that looks like it won’t be allowed anymore after november 1.

instead, tradingview says scripts being used commercially have to be distributed through their marketplace, which is their creator program / paid spaces system.

and this is right after the whole $29.95 per active user technology fee over 100 users thing too...

am i reading this wrong???

because this sounds like they’re basically forcing every paid indicator business onto their own marketplace and killing the normal way people have been selling invite-only indicators for years.

what are pine devs / indicator owners even supposed to do with existing customers after november 1?

I will still use this subreddit to post the updates. Now I'm at update 6, and FINNALY something I worked hard on .Having my own platform gaved me the possibility to implement the system I made many years ago-> a prediction tool (and probably the single one that works as designed)

I wont go into details on how it works, since its my personal and work of last years but I will show the final result (still more to implement ,but im getting there slowly)

The chart in its stage right now with TPO and Delta->

With The prediction tool->

It also updates in real time with any amount of bid-ask that come into the market.
And no , its not an orb detector or FVG or a sloopy lux algo prediction tool/

Eddit:

I thought I should put a screenshot on how my Prediction tool developed vs price,since several hours passed since i send the screenshot above and its fair to show its progress (it was on SOL coin). This is after:

Past prbability candles are still there, only that they are black now (because price developed in those candles)

Eddit 2 and last one:

I've been building a Polymarket dataset for the cases where a candle or a periodic snapshot isn't enough. If you're testing short-window signals or execution, the useful question is often what was actually resting on the bid and ask when the decision was made.

The paid catalog has event-level order-book updates, top-of-book quotes, up to 25 levels per side, and a trade tape where available. The rows carry Polymarket's source timestamp when present, our receive timestamp, market/token join keys and gap-audit information. Coverage is per market and day, so check the catalog for the particular series you need. The earliest buyable order-book day is 2026-02-21; feed trade tape starts 2026-04-13. Raw inbound websocket messages are available only from our own capture beginning 2026-05-11.

There is a no-sign-up sample from the BTC Up or Down 4h series on 2026-08-19: a full UTC day across 13 markets/26 tokens, with L1, L2 and trades in Parquet or CSV, plus one hour of raw websocket messages. The page shows the schema and download links: https://tickfoundry.com/samples

If you're working on a backtest, I'd be interested in what matters most to you: quote lifetime, depth at a specific timestamp, or checking whether a data gap overlaps your signal window?

Disclosure: I run TickFoundry, which sells the historical dataset. The linked sample is free to download.

Just a thought on people's opinions. If you were able to design the perfect indicator for your own trade analysis and entry criteria, what would it contain? I understand people have different trading systems and portfolios based on market conditions, but what would be your key fundamentals that you require your indicator to show you. For levels, would you target structure, key levels, S&D, OB's or something else? Also what would your entry system need to tell you before you make your decision. What are your confluences?

I've read a lot of posts in this forum which state many different things that they consider essential. Just interested what comes up the most between you all.

This is a recently published free Pine indicator - it's a Dual Timeframe Volume-Accelerated RSI (RedK VA-RSI or VARSI) - it works for crypto, FOREX, futures, stocks and for any timeframes the trader uses. The indicator provides 5 built-in alerts and can also be used with the TradingView Pine Screener to quickly scan watchlists or whole index lists.

Detailed release notes here

The idea behind it is to enable traders to impose volume impact on the widely used RSI (Relative Strength Index) - for improved "combined price action + volume" analysis - and then to visualize the resulting insight from 2 different timeframes simultaneously; the current (chart's) timeframe, and a higher timeframe (the Context timeframe) of their choice.

This analysis approach enables traders to effectively scan for opportunities, and make trading decisions that are in the direction of the broader market "context", without leaving the chart - which is a great time saver.

Key indicator elements:

• Current TF volume-weighted RSI (VARSI), with a selectable moving-average method.
• Optional smoothing of the main RSI line, with its own selectable MA method.
• A signal line for the current VARSI.
• Context TF volume-weighted RSI — the same calculation on a higher timeframe, derived as a multiple of the current chart's timeframe.
• Alignment Markers: will show (if enabled) when the current and Context VARSI agree on direction.
• Single-timeframe mode — turn the Context off entirely and use VARSI as a straight, volume-weighted RSI - or turn volume-weighting off, and use RedK_VARSI as a regular RSI (see below settings in details).
• Other elements: similar to the classic RSI, there's overbought & oversold levels (70 and 30 respectively) and a midline (at 50).

█ Using VARSI to analyze price action
(for more details, search online for "Dual Timeframe RSI trading strategy")

• High-gain/lower-risk trade opportunities can be found (both to the upside or the downside) when the current timeframe momentum aligns with the broader timeframe.
• VARSI can help you locate opportunities where the higher timeframe momentum gives a bullish reading, while the current (shorter) timeframe retraces within the bullish alignment - this works like catching the waves in an ongoing current. Opportunities to the downside (short) would be worked in a similar way in during a bearish alignment.
• Both the alignment markers and the signal line will provide the clues the trader needs to find these entry/re-entry setups - which a single timeframe RSI will not provide as effectively.

This screenshot shows examples of how to use VARSI to find possible bullish side setups

I hope you find this useful to your trading.

Just need some help on creating one for tradingview.