A Pine Script strategy can look, on the screen, exactly like a robot placing trades: it enters, exits, tracks a stop and prints a performance summary. It is not placing real trades. TradingView's own documentation describes a broker emulator that simulates fills using chart data, for backtesting on history and forward testing on live bars inside TradingView. Getting a Pine Script strategy to place a real order on a real account needs a broker integration, a webhook to a bridge, or a third-party automation tool sitting between TradingView and the account. Tide, the language behind eTrader Code, starts from the opposite assumption: a Tide robot is built to place real orders on a real trading account from the first line of code.
That single difference in what each language assumes about you shapes almost everything else, from how the code reads to what a beginner learns first. This comparison is for anyone weighing the two for indicators, strategies or fully automated trading in 2026.
What each one is actually built for
Pine Script is TradingView's language for charting first. Most Pine Script is written to draw something on a chart: a moving average, an oscillator, a custom overlay. TradingView's own docs describe strategy scripts as a specialized subset built on top of that, adding functions to simulate entries and exits against the broker emulator so a script's historical and forward performance can be measured. The language recalculates on every bar and on every incoming tick, which is a natural fit for something that is, first and foremost, drawn on a chart in front of a person.
Tide has no charting-only mode. Every Tide program is either a robot that compiles to an .etb bundle and runs in eTrader's cloud, or an indicator that compiles to an .eti file and draws on a chart, and even the indicator side exists to support automated and semi-automated trading rather than pure visual analysis. A Tide robot places real orders through calls like trade.buy(volume, sl: stop, tp: target, comment: "text"), which return a result with ok, ticket and message fields the robot can act on immediately, either in Trade mode, which places the order, or Signals only mode, which sends a push notification and logs the decision without touching the account.
The mental model: series and guards versus bars and plots
Tide leans on a type system built specifically for trading. It has price and lots as distinct types, so a value meant as a price can never be passed where a lot size is expected, alongside int, num, bool, text, time, duration, series<T>, array<T>, map, struct and enum. A series holds one value per candle and lifts automatically over arithmetic, so a calculation across history does not need an explicit loop. Control flow adds trading-specific keywords beyond the ordinary if, match, for and while: guard exits a block early when a condition is not met, once runs a block only on the very first tick, and every(duration) throttles a block so it fires no more often than a set interval, useful for anything that should not run on every single tick.
Pine Script's mental model centers on the current bar. A script re-evaluates its logic each time a new bar forms or a tick arrives, and most built-in functions, like a moving average call, operate on a rolling series of bars behind the scenes without the author writing a loop either, in a broadly similar way to Tide's automatic series lifting. Where Pine Script differs is in what a script does with its output: `plot()` draws a line, `strategy.entry()` and `strategy.close()` send hypothetical orders to the broker emulator, and `alertcondition()` or `alert()` can fire an alert a person watches or a webhook a bridge listens for. The language is built to describe what is happening on a chart and, for strategy scripts, to simulate what would happen if a person or a bridge acted on it.
| Aspect | Tide | Pine Script |
|---|---|---|
| Primary purpose | Automated trading: robots that place real orders | Charting and analysis first; strategy scripts add backtesting on top |
| Live order placement | Built in: trade.buy() / trade.sell() place real orders directly | Not built in: needs a broker integration, a webhook, or a third-party bridge |
| Backtesting | Deterministic replay of the firm's real price history in the cloud | TradingView's own broker emulator, on historical and realtime bars |
| Type system | Strict, trading-specific types including price and lots | Looser scripting types built around series of bar values |
| Where it runs | eTrader's cloud, no VPS | TradingView's servers for the script itself; live execution runs elsewhere |
Backtesting: two different jobs
TradingView's broker emulator simulates fills using the OHLC data available on the chart, running the same strategy code across history and then, if left running, across new bars as they arrive in real time. It is a strong tool for testing an idea's shape quickly on any of TradingView's charts, across a huge range of instruments the platform lists. What it cannot do on its own, by the platform's own design, is place a real order. TradingView's documentation is explicit that the broker emulator's fills are simulated, not real trades, and that live trading needs a connection outside Pine Script itself.
Tide's backtester replays a firm's own historical candles deterministically: identical bytecode, inputs and candles always produce identical simulated trades, shown with an equity curve and every trade in the run. Because a Tide robot and its backtest run against the same price history it will later trade live on, in the same cloud environment, there is no separate broker emulator or data source to reconcile against the live account once the robot is switched on. For a broader look at how backtesting differs across three platforms, see backtesting tools compared and backtest overfitting.
From an idea on a chart to an order on an account
A trader who writes a Pine Script strategy and wants it to trade a real account has choices, all of them outside Pine Script itself: connect a broker that supports TradingView's execution integrations, send `alert()` messages as webhooks to a bridge service that turns them into orders, or build a custom listener. Every one of those paths adds a moving part between the idea and the account, and each one is a place something can go wrong: a missed alert, a webhook that fails silently, a bridge that is down when the market moves. See webhook automation safety for what to check before relying on that chain.
A Tide robot skips that chain by design. Because the language itself has trade calls, sandboxing rules, and cloud hosting built in, from `onBar` or `onTick` straight through to a filled order, there is one fewer external service to keep online. The trade-off is that a Tide robot only trades an eTrader account; it does not draw on TradingView's chart or its community the way a Pine Script indicator can be shared and discussed across a huge base of TradingView users.
Who each one suits
A trader whose main activity is visual chart analysis, who wants to publish indicators to a wide audience, or who tests ideas across many different markets and brokers before deciding where to actually trade, gets more from Pine Script and TradingView's charting tools. A trader or firm that wants a script to place real orders directly, without assembling a webhook bridge, and that is willing to trade only on eTrader in exchange for that directness, is better served by Tide. Some teams use both: chart and prototype in Pine Script, then rebuild the final trading logic by hand in Tide once it is proven, since there is no automatic converter between the two languages.
"Pine Script and Tide solve different problems. Pine Script tells you what a strategy would have done. Tide is the one that actually places the order."
— The SGHK Team
Key Takeaways
- Pine Script strategies run against TradingView's own broker emulator and do not place real trades directly; live execution needs a broker integration or a webhook bridge.
- Tide robots place real orders directly through calls like
trade.buy(), running in eTrader's cloud with no external bridge required. - Both languages lift calculations across a series of bars automatically, but Tide's type system adds trading-specific types like
priceandlotsthat Pine Script does not have. - There is no automatic converter between Pine Script and Tide; a strategy that needs to run as a live eTrader robot is rewritten by hand.
Frequently Asked Questions
Can a Pine Script strategy place real trades on a broker account?
Not directly. TradingView's own documentation describes strategy scripts as running against a broker emulator that simulates fills for backtesting and forward testing inside TradingView. Placing a real trade needs a broker integration TradingView supports, a webhook sent to a third-party bridge, or another automation tool connected outside Pine Script itself.
Does Tide have anything like TradingView's charting and community?
No. Tide is a language for writing eTrader robots and indicators, not a public charting platform. Its indicators draw on eTrader's own chart for the trader using them, but there is no equivalent to publishing a script to a wide public audience the way TradingView supports.
Can a Pine Script indicator be converted into a Tide indicator automatically?
No. There is no automatic converter between Pine Script and Tide. A trader who wants the same logic running as an eTrader indicator or robot needs to rewrite it by hand using Tide's own types and event handlers.
Which language is easier for a beginner with no coding background?
Both are designed to be approachable relative to a general-purpose language. Pine Script has a large body of public tutorials and example scripts to learn from because of TradingView's community size. Tide's input declarations auto-generate the settings form a trader sees before installing a robot, and its editor flags mistakes as they are typed, which shortens the loop from writing code to seeing it run.
Do backtests in Pine Script and Tide use the same price data?
No. A Pine Script backtest uses TradingView's own chart data and broker emulator. A Tide backtest replays the firm's own price history inside eTrader, the same history the live robot will later trade on, which is why results carry over from backtest to live without a separate data reconciliation step.
About SGHK
SGHK is a FinTech company that designs and builds its own software for the trading industry: the eTrader trading platform, Launch your Broker and Launch your Prop Firm. Every product is written, hosted and supported in-house and licensed to trading firms, with the CRMs branded to them, all hosted by us in the cloud, managed by each firm and built to scale across clustered servers as our clients grow. Everything is encrypted, and each firm is the only one with access to its data and its clients' data.