A cBot written for cTrader Automate (also called cTrader Algo) can, in principle, do almost anything C# and the .NET runtime allow it to do: read a file, open a network socket to any address, spawn a thread. A robot written in Tide for eTrader Code cannot do any of that unless it declares the capability up front, and even then it is capped by a step budget and a memory limit the platform enforces at runtime. Neither approach is simply better. They are answers to a different question: how much freedom should a trading robot have by default?
This comparison is for a firm or a developer deciding between two real, current options for building automated trading robots: cTrader's full C#/.NET environment, and Tide, eTrader's own domain-specific language.
Two different starting points
cTrader Automate gives a developer the entire C# language and, through it, the full .NET ecosystem: NuGet packages, general-purpose libraries, whatever a developer already knows how to do in C# for any other kind of software. A cBot is a C# class that reacts to events like a new tick or a new bar and calls into cTrader's API to manage orders and positions. Anyone who already writes C# professionally starts from familiar ground: the syntax, the tooling, the debugger, even the mental model of classes and interfaces.
Tide starts from a much narrower base, because it was built for one purpose only: automated trading. A robot declares metadata, inputs, indicators and event handlers like onInit, onBar, onTick, onFilled, onClosed, onTimer and onWebhook, and trades are placed with single calls using named arguments, for example trade.buy(volume, sl: stop, tp: target, comment: "text"). There is no general standard library to reach for outside the trading domain. What Tide has instead is a type system built for the job: price and lots are separate types, so one can never be passed where the other belongs, alongside int, num, bool, text, time, duration, series<T>, array<T>, map, struct and enum, with series values lifting automatically over history without an explicit loop.
Permissions and sandboxing: the real philosophical difference
C# in cTrader Automate follows the general-purpose language philosophy: the developer is trusted with broad access, and the responsibility for staying safe, not calling an unbounded loop, not leaking memory, not connecting to something it should not, sits with the developer and whatever review process the firm runs before deploying a cBot. That freedom is exactly why C# suits complex, custom logic that does not fit neatly into a smaller trading-specific language. It also means the attack surface and the space for subtle bugs are both larger, and debugging a live cBot draws on the same general .NET debugging skills as debugging any other C# application, which is a strength for a team that already has those skills and a cost for a team that does not.
Tide flips the default. A bundle declares its capabilities before it is ever installed, including any network host it wants to call, using a permissions block such as permissions { network "api.example.com" } before it can use http.json(...) to reach that host. Runtime limits are fixed by the platform: a step budget per event (2,000,000 steps in the cloud, 500,000 on a chart), memory caps (32 MB cloud, 16 MB chart), and history depth limits (100,000 candles cloud, 20,000 chart). A bot can never see another bot's state, reach an address it did not declare, or run native code. The trader installing a robot sees its declared capabilities before granting them, the way an app store shows permissions before an install. Tide's documented gaps, no ONNX or Python bridges, no GPU access, no SQL database access, are a direct consequence of this narrower, sandboxed design, not oversights: where a strategy genuinely needs a capability, Tide is built to add its own version of it rather than open the sandbox generally.
| Aspect | Tide (eTrader Code) | C# (cTrader Automate / cTrader Algo) |
|---|---|---|
| Language scope | Domain-specific, trading only | Full general-purpose language and the .NET ecosystem |
| Permissions model | Capabilities declared up front; step budget and memory cap enforced at runtime | General .NET access; safety is the developer's and reviewer's responsibility |
| Where it runs | eTrader's cloud, no VPS | The cTrader desktop or a VPS running cTrader |
| Best suited to | Traders who want a smaller, safer language purpose-built for trading | Developers who already know C# and want general-purpose flexibility |
| Backtesting | Deterministic replay of the firm's own price history in the cloud | cTrader's own backtesting inside the desktop or web platform |
Backtesting approach
cTrader's backtesting runs inside the cTrader platform itself, against historical price data cTrader provides, and gives a C# developer the same debugging and iteration tools available for any cBot: breakpoints, logging, the ordinary .NET workflow. It fits naturally with a development style built around an IDE and a desktop-first workflow.
Tide's backtester replays historical candles from the firm's own price history deterministically: identical bytecode, inputs and candles always produce identical trades, and the result is shown as an equity curve with every trade in the run. Because the backtest and the live robot draw on the same price history in the same cloud environment, there is no separate data source to reconcile once the robot goes live. See backtesting compared across MT5, cTrader and eTrader for a fuller look at how the three approaches differ in practice.
Who each one suits
A developer who already writes C# professionally, wants access to the full .NET ecosystem, and is comfortable owning the safety and review of their own code will get more out of cTrader Automate. A trader who wants to build robots without taking on a general-purpose language's full surface area, and who values a platform that shows a robot's declared permissions before granting them, is better served by Tide, built into eTrader Code. Neither replaces genuine trading judgment: a permissions model and a step budget stop a robot from misbehaving outside its declared scope, they do not stop a bad strategy from losing money.
Firms comparing the two platforms as a whole, beyond the automation layer alone, can read the fuller picture in eTrader vs cTrader.
What moving between the two actually involves
There is no automatic converter from C# cBots to Tide, or the other way around. A cBot's trading logic has to be read and rewritten by hand into Tide's event handlers and named-argument trade calls, and a Tide robot moving the other way has to be rebuilt as a proper C# class against cTrader's API. The rewrite is usually smaller than it sounds for a simple robot, since both languages share the same underlying concepts, on a new bar, check a condition, place or close a trade, but any use of general C# libraries or complex object hierarchies inside a cBot has no direct equivalent in Tide's sandboxed model and needs a different approach entirely.
"C# gives a developer the whole language and expects them to use it responsibly. Tide gives a trader a smaller language and enforces the responsible part for them."
— The SGHK Team
Key Takeaways
- cTrader Automate (cTrader Algo) gives developers the full C# language and .NET ecosystem, with safety left to the developer and reviewer.
- Tide declares a robot's capabilities up front and enforces step budgets, memory caps and network restrictions at runtime, visible to the trader before install.
- cBots run in the cTrader desktop or a VPS; Tide robots run in eTrader's cloud with no VPS required.
- There is no automatic converter between the two; a robot moving from one platform to the other is rewritten by hand.
Frequently Asked Questions
Is cTrader Automate the same thing as cTrader Algo?
Yes. cTrader Automate is Spotware's current name for its C# automated trading environment, sometimes still called cTrader Algo, including in Spotware's own help-portal URLs. Both names refer to the same feature: writing cBots and custom indicators in C# that run inside cTrader.
Does Tide support object-oriented programming like C#?
Tide has structured types like struct, enum and reusable .tidelib library files with exported pub functions, but it is not a general-purpose object-oriented language the way C# is. It does not have class inheritance or the broader .NET type system a cBot can use.
Can a cBot access the internet or a database directly?
A cBot has the general access C# and .NET provide, subject to whatever the cTrader environment and the developer's own code allow. A Tide robot can only reach a network host it has explicitly declared under a permissions block, and has no built-in SQL database access at all, by design.
Which language is safer to run unattended?
Tide's sandboxing, declared permissions, step budgets, memory caps and no access to another bot's state, is built specifically to limit what an unattended robot can do if something goes wrong. C# gives a cBot broader access, which suits complex logic but places more of the responsibility for safe unattended operation on the developer and the firm's own review process.
Can a C# cBot be converted automatically into a Tide robot?
No. There is no automatic converter in either direction. A robot's trading logic has to be read and rewritten by hand, using Tide's event handlers and named-argument trade calls in place of cTrader's C# API.
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.