Dokumentation

Deepwick-Script-Referenz

Deepwick Script ist die Sprache der Charts und Backtests von Deepwick. Sie führt eine Teilmenge von Pine Script aus: Die meisten Funktionen ta.*, math.*, str.*, input.*, plot* und strategy.* laufen unverändert, und nicht unterstützte Zeilen werden mit Zeile und Spalte markiert. Diese Seite listet alles, was die Engine heute kann — und was nicht.

Neu bei Deepwick? Beginne mit der Anleitung Schritt für Schritt: Eine Pine-Script-Strategie kostenlos backtesten.

Du baust eine KI, die Deepwick Script schreibt? Diese Referenz als ein einziges Markdown-Dokument.

Aktualisiert: 2026-10-03

Sprache

Deepwick Script führt eine Teilmenge von Pine Script aus, darunter Enums, benutzerdefinierte Typen, Methoden und Maps; die Zeile //@version wird nicht erzwungen. Ein Script läuft einmal pro Kerze, von der ältesten zur neuesten, und jede Variable behält ihren Verlauf.

Syntax	Was es tut
`x = expr / x := expr`	Deklariert eine Variable und weist ihr danach mit := einen neuen Wert zu. Ein optionaler Typ (int, float, bool, string, color, series, simple, const, line, label) darf dem Namen vorausgehen.
`var / varip`	Initialisiert sich einmal auf der ersten Kerze und behält den Wert über die Kerzen hinweg. varip verhält sich wie var, weil Scripts auf geschlossenen Kerzen laufen.
`x[n]`	Historienoperator: der Wert von x vor n Kerzen (na vor der ersten Kerze).
`if / else`	Bedingte Blöcke, um vier Leerzeichen eingerückt. if kann auch als Ausdruck verwendet werden.
`cond ? a : b`	Ternärer Operator.
`switch`	Mehrfachverzweigung, mit oder ohne zu vergleichenden Wert.
`for i = a to b [by step]`	Zählschleife. break und continue werden unterstützt.
`while cond`	Schleife, solange eine Bedingung gilt.
`f(x, y) => expr`	Benutzerdefinierte Funktion, einzeilig oder als eingerückter Block, dessen letzter Ausdruck zurückgegeben wird. Jede Aufrufstelle behält ihren eigenen ta.*-Zustand, wie in Pine.
`[a, b] = f()`	Tupel: Funktionen können mehrere Werte zurückgeben, und eingebaute wie ta.macd() und ta.bb() tun das.
`and / or / not`	Logische Operatoren. Arithmetik: + - * / %; Vergleich: == != < <= > >=.

Deklarationen

Syntax	Was es tut
`indicator(title, shorttitle, overlay, precision)`	Deklariert einen Indikator: Er zeichnet auf dem Chart und hat nichts zu backtesten. study() wird als Alias akzeptiert.
`strategy(title, overlay, initial_capital, default_qty_type, default_qty_value, commission_type, commission_value, slippage, pyramiding)`	Deklariert eine Strategie. Vorgaben: initial_capital 100000, 1 Kontrakt pro Order, Provision 0, Slippage 0 Ticks, Pyramiding 1. Andere Argumente wie process_orders_on_close werden ignoriert.

Eingaben

Eingaben erscheinen neben dem Editor und in den Einstellungen des Indikators, damit du sie ändern kannst, ohne den Code anzufassen.

Syntax	Was es tut
`input.int(defval, title, minval, maxval, step)`	Ganzzahl.
`input.float(defval, title, minval, maxval, step)`	Dezimalzahl.
`input.bool(defval, title)`	Kontrollkästchen.
`input.string(defval, title, options)`	Text oder eine Liste von Optionen.
`input.session(defval, title)`	Eine Handelssitzung wie "0930-1600" oder Tage wie "23456". Übergib sie an session.ismarket() und die anderen session.*-Prädikate.
`input.source(defval, title)`	Eine Preisquelle: open, high, low, close, hl2, hlc3, ohlc4 oder hlcc4.
`input.color(defval, title)`	Farbwähler.
`input(defval, title)`	Generische Eingabe; der Typ folgt dem Standardwert.

Kerzendaten und Zeit

Zeiten sind UTC-Millisekunden. hour() und die anderen Zeitfunktionen nehmen eine optionale Zeit entgegen; hour() nimmt zusätzlich eine Zeitzone aus einer festen Liste von Versatzungen entgegen, ohne Sommerzeit.

Syntax	Was es tut
`open, high, low, close, volume`	Preise und Volumen der aktuellen Kerze.
`hl2, hlc3, ohlc4, hlcc4`	Übliche Preisdurchschnitte.
`bar_index, last_bar_index`	Index der aktuellen Kerze (0 ist die älteste) und der letzten Kerze.
`time, time_close`	Eröffnungs- und Schlusszeit der Kerze. Als Funktionen — time("D"), time(timeframe.period, "0000-0900:23456", "UTC") — der Anfang (oder das Ende) der Kerze höherer Zeiteinheit, die diese enthält, oder na, wenn die Kerze außerhalb der Sitzung liegt. Sitzungen: "HHMM-HHMM", auch über Nacht, mehrere durch Kommas getrennte Fenster, optionale Tage nach einem Doppelpunkt (1 = Sonntag … 7 = Samstag), "24x7".
`timeframe.change(timeframe)`	Wahr auf der ersten Kerze jedes neuen Zeitraums, z. B. timeframe.change("D") auf der ersten Kerze jedes Tages (Wochen beginnen am Montag).
`timestamp(timezone?, year, month, day, hour, minute, second)`	Eine Zeit in Millisekunden aus ihren Teilen oder aus einem Datumsstring: timestamp("2026-01-05T09:30:00Z").
`dayofweek.sunday … dayofweek.saturday`	Tageskonstanten zum Vergleich mit dayofweek (1 … 7).
`session.ismarket, isfirstbar, islastbar, ispremarket, ispostmarket`	Sitzungszustand. Die Märkte hier handeln rund um die Uhr, deshalb liegt jede Kerze in der Marktsitzung; isfirstbar / islastbar markieren die erste und die letzte Kerze jedes UTC-Tages.
`year, month, weekofyear, dayofmonth, dayofweek, hour, minute, second`	Kalenderbestandteile der Kerzenzeit; auch mit einer Zeit aufrufbar, z. B. hour(time, "America/New_York"). dayofweek: 1 = Sonntag … 7 = Samstag.
`barstate.isfirst, islast, isnew, isconfirmed, ishistory, isrealtime`	Wo das Script im Kerzenverlauf steht.
`timeframe.period, multiplier, isintraday, isdaily, isweekly, ismonthly`	Die Zeiteinheit des Charts.
`syminfo.ticker, tickerid, mintick, pointvalue`	Das Symbol des Charts, seine Preisschrittweite und sein Punktwert.

Technische Analyse (ta.*)

Jede Aufrufstelle behält ihren eigenen Zustand, wie in Pine: zwei ta.ema()-Aufrufe auf verschiedenen Zeilen sind zwei unabhängige Durchschnitte. Das Ergebnis ist na, bis genügend Kerzen vorliegen.

Syntax	Was es tut
`ta.sma(source, length)`	Einfacher gleitender Durchschnitt.
`ta.ema(source, length)`	Exponentieller gleitender Durchschnitt.
`ta.rma(source, length)`	Wilder-Durchschnitt, den RSI und ATR verwenden.
`ta.wma(source, length)`	Gewichteter gleitender Durchschnitt.
`ta.vwma(source, length)`	Volumengewichteter gleitender Durchschnitt.
`ta.hma(source, length)`	Hull-Durchschnitt.
`ta.linreg(source, length, offset)`	Wert der linearen Regressionsgeraden.
`ta.vwap(source)`	Volumengewichteter Durchschnittspreis, der jeden Tag um 00:00 UTC neu beginnt.
`ta.rsi(source, length)`	Relative Strength Index, 0 bis 100.
`ta.macd(source, fastlen, slowlen, siglen)`	Gibt [macd, signal, histogram] zurück.
`ta.stoch(source, high, low, length)`	Stochastik %K, 0 bis 100.
`ta.cci(source, length)`	Commodity Channel Index.
`ta.mfi(series, length)`	Money Flow Index.
`ta.wpr(length)`	Williams %R, -100 bis 0.
`ta.dmi(diLength, adxSmoothing)`	Gibt [+DI, -DI, ADX] zurück.
`ta.supertrend(factor, atrPeriod)`	Gibt [supertrend, direction] zurück; die Richtung ist -1 im Aufwärtstrend und 1 im Abwärtstrend.
`ta.sar(start, inc, max)`	Parabolischer SAR.
`ta.mom(source, length)`	Momentum: die Quelle minus die Quelle von vor length Kerzen.
`ta.roc(source, length)`	Veränderungsrate, in Prozent.
`ta.change(source, length)`	Differenz zu vor length Kerzen (standardmäßig 1).
`ta.tr / ta.tr(handle_na)`	True Range.
`ta.atr(length)`	Average True Range (Wilder).
`ta.bb(series, length, mult)`	Bollinger-Bänder: gibt [middle, upper, lower] zurück.
`ta.bbw(series, length, mult)`	Bollinger-Bänderbreite: (upper - lower) / middle.
`ta.kc(series, length, mult)`	Keltner-Kanäle: gibt [middle, upper, lower] zurück, mit einem EMA der True Range.
`ta.stdev(source, length, biased)`	Standardabweichung.
`ta.variance(source, length, biased)`	Varianz.
`ta.dev(source, length)`	Mittlere absolute Abweichung.
`ta.median(source, length)`	Median.
`ta.highest(source, length) / ta.highest(length)`	Höchster Wert über length Kerzen (standardmäßig der high).
`ta.lowest(source, length) / ta.lowest(length)`	Niedrigster Wert über length Kerzen (standardmäßig der low).
`ta.highestbars(source, length)`	Versatz zum höchsten Wert: 0 oder negativ.
`ta.lowestbars(source, length)`	Versatz zum niedrigsten Wert: 0 oder negativ.
`ta.rising(source, length)`	Wahr, wenn die Quelle über jedem ihrer previous length Werte liegt.
`ta.falling(source, length)`	Wahr, wenn die Quelle unter jedem ihrer previous length Werte liegt.
`ta.crossover(source1, source2)`	Wahr auf der Kerze, auf der source1 über source2 kreuzt.
`ta.crossunder(source1, source2)`	Wahr auf der Kerze, auf der source1 unter source2 kreuzt.
`ta.cross(source1, source2)`	Wahr bei einem Kreuz in beide Richtungen.
`ta.pivothigh(source, leftbars, rightbars)`	Der Pivot-High-Preis, bekannt rightbars Kerzen nach dem Pivot; sonst na. Die Quelle ist optional (standardmäßig der high).
`ta.pivotlow(source, leftbars, rightbars)`	Der Pivot-Low-Preis, bekannt rightbars Kerzen nach dem Pivot; sonst na. Die Quelle ist optional (standardmäßig der low).
`ta.valuewhen(condition, source, occurrence)`	Wert der Quelle auf dem occurrence-ten zuletzt zurückliegenden Kerzen, auf dem die Bedingung wahr war.
`ta.barssince(condition)`	Kerzen seit dem letzten Mal, dass die Bedingung wahr war.
`ta.cum(source)`	Laufende Summe seit der ersten Kerze.

Andere Zeiteinheiten (request.*)

Eine höhere Zeiteinheit wird aus den Kerzen des Charts selbst gebaut, sie braucht also keine Daten, die die Engine nicht hat. Der Wert einer Kerze höherer Zeiteinheit wird erst auf der Chart-Kerze NACH ihrem Schluss sichtbar: eine 4h-Kerze ist von innen nie lesbar, und genau das hält einen Backtest ehrlich.

Syntax Was es tut

request.security(symbol, timeframe, expression) Führt expression auf einer höheren Zeiteinheit DESSELBEN Symbols aus und gibt den letzten GESCHLOSSENEN Wert zurück. Funktioniert mit dem Symbol des Charts (oder syminfo.tickerid oder einem leeren Symbol); ein anderes Symbol liefert na, weil die Engine nur die Kerzen des Charts hält. Zeiteinheiten akzeptieren die Schreibweise von Pine ("60", "240", "D", "W", "M") und die von Deepwick ("1h", "4h", "1d"). Der Ausdruck darf ein ta.*-Aufruf sein, der über die Serie der höheren Zeiteinheit ausgewertet wird. Liefert na, bis eine solche Kerze geschlossen ist.

request.security(..., lookahead) Akzeptiert und ignoriert. lookahead_on würde einen Backtest die entstehende Kerze höherer Zeiteinheit lesen lassen, und das wäre ein Blick in die Zukunft; die Engine schaut nie hin. gaps wirkt nur auf das Zeichnen innerhalb der Kerze, was hier nicht greift.

Syntax	Was es tut
`request.security(symbol, timeframe, expression)`	Führt expression auf einer höheren Zeiteinheit DESSELBEN Symbols aus und gibt den letzten GESCHLOSSENEN Wert zurück. Funktioniert mit dem Symbol des Charts (oder syminfo.tickerid oder einem leeren Symbol); ein anderes Symbol liefert na, weil die Engine nur die Kerzen des Charts hält. Zeiteinheiten akzeptieren die Schreibweise von Pine ("60", "240", "D", "W", "M") und die von Deepwick ("1h", "4h", "1d"). Der Ausdruck darf ein ta.*-Aufruf sein, der über die Serie der höheren Zeiteinheit ausgewertet wird. Liefert na, bis eine solche Kerze geschlossen ist.
`request.security(..., lookahead)`	Akzeptiert und ignoriert. lookahead_on würde einen Backtest die entstehende Kerze höherer Zeiteinheit lesen lassen, und das wäre ein Blick in die Zukunft; die Engine schaut nie hin. gaps wirkt nur auf das Zeichnen innerhalb der Kerze, was hier nicht greift.

Strategien (strategy.*)

Market-Orders werden zur Eröffnung der nächsten Kerze ausgeführt. Stop- und Limit-Orders werden entlang der Kerze ausgeführt: Eröffnung, dann das Extrem näher an der Eröffnung, dann das andere Extrem, dann der Schluss. Springt der Preis über eine Order hinweg, wird sie zur Eröffnung ausgeführt. Provision wird bei jeder Ausführung berechnet; Slippage gilt für Market- und Stop-Ausführungen.

Syntax	Was es tut
`strategy.entry(id, direction, qty, limit, stop, comment)`	Eröffnet oder erhöht eine Position; Market-Order, sofern nicht limit oder stop angegeben ist.
`strategy.order(id, direction, qty, limit, stop, comment)`	Dieselben Argumente wie strategy.entry().
`strategy.exit(id, from_entry, qty_percent, profit, limit, loss, stop, trail_points, trail_offset, comment)`	Take-Profit, Stop-Loss und Trailing Stop für einen Einstieg: Gewinn und Verlust in Ticks, limit und stop als Preise. trail_points ist der Abstand in TICKS vom besten erreichten Preis; trail_offset ist der Gewinn in Ticks, der geräumt sein muss, bevor der Trailing Stop scharf wird. Der Stop ratchet stets nur zu deinen Gunsten und bewegt sich auf GESCHLOSSENEN Kerzen, damit kann eine Kerze nie den Stop auslösen, den ihr eigenes Hoch gesetzt hat.
`strategy.close(id, comment, qty_percent)`	Schließt einen Einstieg zur nächsten Kerze zum Marktpreis.
`strategy.close_all(comment)`	Schließt alle offenen Positionen.
`strategy.cancel(id) / strategy.cancel_all()`	Bricht offene Orders ab.
`strategy.position_size, position_avg_price`	Aktuelle Position (positiv long, negativ short) und ihr Durchschnittspreis.
`strategy.opentrades.entry_bar_index(n), entry_price, entry_time, entry_id, size, profit, commission, max_runup, max_drawdown`	Details der offenen Position n (0 = älteste); na, wenn es keine gibt. size ist bei Shorts negativ. Z. B. Ausstieg nach 10 Kerzen: bar_index - strategy.opentrades.entry_bar_index(0) >= 10.
`strategy.closedtrades.entry_bar_index(n), exit_bar_index, entry_price, exit_price, entry_time, exit_time, entry_id, size, profit, commission, max_runup, max_drawdown`	Details der geschlossenen Position n (0 = älteste; die letzte ist strategy.closedtrades - 1).
`strategy.equity, netprofit, openprofit, grossprofit, grossloss, initial_capital`	Kontowerte.
`strategy.closedtrades, opentrades, wintrades, losstrades`	Anzahl der Trades.
`strategy.long, strategy.short`	Richtungen.
`strategy.fixed, strategy.cash, strategy.percent_of_equity`	Werte für default_qty_type.
`strategy.commission.percent, cash_per_order, cash_per_contract`	Werte für commission_type.

Charts und Alarme

Syntax	Was es tut
`plot(series, title, color, linewidth, style)`	Zeichnet eine Serie auf dem Chart oder in einem Fenster.
`plotshape(series, title, style, location, color, text)`	Zeichnet eine Form auf den Kerzen, auf denen series wahr ist.
`plotchar(series, title, char, location, color)`	Zeichnet ein Zeichen auf den Kerzen, auf denen series wahr ist.
`hline(price, title, color, linestyle)`	Waagerechte Linie auf einem festen Niveau.
`fill(plot1, plot2, color)`	Füllt zwischen zwei Charts oder zwei hlines.
`bgcolor(color)`	Färbt den Hintergrund der Kerze.
`barcolor(color)`	Färbt die Kerze selbst.
`alertcondition(condition, title, message)`	Deklariert eine Bedingung, die du per E-Mail, Telegram, Discord oder webhook zu einem Alarm machen kannst.
`plot.style_*`	line, linebr, stepline, histogram, columns, circles, cross, area.
`hline.style_*`	solid, dashed, dotted.
`shape.*`	triangleup, triangledown, arrowup, arrowdown, circle, xcross, cross, diamond, square, flag, labelup, labeldown.
`location.*`	abovebar, belowbar, top, bottom, absolute.
`size.*`	auto, tiny, small, normal, large, huge. Akzeptiert, aber Formen werden in einer einzigen Größe gezeichnet.

Linien und Kästen

Syntax	Was es tut
`line.new(x1, y1, x2, y2, extend, color, style, width)`	Zeichnet eine Linie zwischen zwei Kerzenindizes und Preisen; gibt ihre id zurück.
`line.set_x1, set_y1, set_x2, set_y2, set_xy1, set_xy2, set_color, set_style, set_width`	Ändert eine Linie.
`line.delete(id)`	Entfernt eine Linie.
`box.new(left, top, right, bottom, border_color, bgcolor, extend)`	Zeichnet ein Rechteck; gibt seine id zurück.
`box.set_left, set_top, set_right, set_bottom, set_bgcolor, set_border_color, set_extend`	Ändert einen Kasten.
`box.delete(id)`	Entfernt einen Kasten.
`line.style_, box.style_`	solid, dashed, dotted.
`extend.*`	none, left, right, both.

Mathematik, Zeichenketten und Farben

Syntax	Was es tut
`math.abs, ceil, floor, round(number, precision), sign, sqrt, exp, log, log10, pow(base, exponent)`	Arithmetik.
`math.max(...), math.min(...), math.avg(...)`	Über eine beliebige Anzahl von Werten.
`math.sum(source, length)`	Summe über die letzten length Kerzen.
`math.pi, math.e`	Konstanten.
`na, na(x), nz(x, replacement), fixnan(x)`	Der fehlende Wert, ein Test darauf, ein Ersatz dafür und der letzte Wert, der nicht na ist.
`int(x), float(x), bool(x)`	Konvertierungen.
`str.tostring(value, format), str.format(text, ...), str.length(s), str.contains(s, part)`	Zeichenketten. str.format ersetzt {0}, {1}… durch die Argumente.
`color.new(color, transp), color.rgb(red, green, blue, transp)`	Erzeugt eine Farbe; die Transparenz geht von 0 bis 100.
`color.*`	red, green, blue, orange, yellow, purple, aqua, lime, fuchsia, teal, maroon, navy, olive, gray, silver, white, black.

Arrays (array.*)

Syntax	Was es tut
`array.new_float, new_int, new_bool, new_string, new_color, new_line, new_box, new_label, new_table(size)`	Erzeugt ein Array.
`array.get, set, insert, push, pop, shift, unshift`	Liest und ändert Elemente.
`array.size, first, last, sum, avg, min, max, stdev`	Größe und Statistik.

Maps und benutzerdefinierte Typen

Benutzerdefinierte Typen und die Sammlung `map.<fn>` werden unterstützt. Beides sind Deklarationen auf oberster Ebene; Instanzmethoden auf einem Wert nutzen die Syntax `obj.method(args...)`.

Syntax	Was es tut
`enum Name Member Member = N ...`	Enum-Deklaration auf oberster Ebene. Mitglieder ohne Wert zählen automatisch ab 0 hoch; explizite Werte dürfen Zahlen oder Zeichenketten sein. Zugriff als `Name.Member` an jeder Stelle eines Ausdrucks. Enum-Werte sind einfache Zahlen (oder Zeichenketten) und funktionieren daher mit Vergleichsoperatoren und mit `int()` ohne Konvertierung.
`type Name field1 field2: int field3 = default`	Benutzerdefinierter Typ auf oberster Ebene. Die Felder stehen einer pro Zeile; die Teile `: type` und `= default` werden für die Kompatibilität akzeptiert, aber noch nicht geprüft. Erzeuge ihn mit `Type.new(arg1, arg2, ...)` und lies Felder mit `instance.field`.
`m = map.new<int, float>()`	Erzeugt eine leere Map. Typargumente `<K, V>` werden akzeptiert, aber zur Laufzeit ignoriert.
`m = map.put(m, key, value)`	Setzt einen Schlüssel. Gibt die Map zurück, damit Aufrufe verkettet oder neu zugewiesen werden können.
`v = map.get(m, key)`	Liest einen Wert. Gibt na zurück, wenn der Schlüssel fehlt.
`n = map.size(m)`	Anzahl der Einträge.
`keys = map.keys(m), values = map.values(m)`	Gibt die Schlüssel oder Werte als Pine-Array zurück (Einfügereihenfolge).
`map.contains(m, key), map.remove(m, key)`	Zugehörigkeitstest und Löschen. Beide geben die Map zurück.

Noch nicht unterstützt

Eine der Engine unbekannte Funktion stoppt das Script mit „Unknown function“ samt Zeile und Spalte.

Syntax	Was es tut
`label.new(), table.new()`	Noch nicht verfügbar. Linien und Kästen schon.
`import, matrix.*, array.new<type>()`	Bibliotheken, Matrizen und typisierte Array-Konstruktoren sind noch nicht implementiert.
`strategy.risk.*`	Die Risikoregeln (max_position_size, max_intraday_loss, max_drawdown, allow_entry_in) werden nicht unterstützt. Trailing Stops in strategy.exit() schon: benutze trail_points und trail_offset.

Fragen

Ist Deepwick Script dasselbe wie Pine Script?

Nein. Es ist die eigene Engine von Deepwick, die eine Teilmenge von Pine Script ausführt: die Funktionen auf dieser Seite. Die meisten Aufrufe von ta.*, math.*, str.*, input.*, plot* und strategy.* laufen unverändert; nicht unterstützte Zeilen werden mit Zeile und Spalte markiert. Deepwick ist nicht mit TradingView affiliated; Pine Script ist eine Marke der TradingView, Inc.

Welche Pine-Script-Funktionen unterstützt Deepwick Script?

Deepwick Script führt eine Teilmenge von Pine Script aus, darunter Enums, benutzerdefinierte Typen (`type`), Methodendeklarationen und die Sammlung `map.*`. Noch nicht implementiert: Bibliotheken (`import`), `matrix.*` und typisierte `array.new<type>()`-Konstruktoren; der Editor meldet sie mit der genauen Zeile und Spalte. Die Zeile //@version wird nicht erzwungen. Füge ein Script in den Editor ein, um zu sehen, welche Zeilen laufen.

Unterstützt Deepwick request.security()?

Ja, für eine höhere Zeiteinheit des Symbols des Charts selbst. request.security(syminfo.tickerid, "240", close) gibt den letzten GESCHLOSSENEN 4h-Schluss zurück, und der Ausdruck darf ein ta.*-Aufruf sein. Ein anderes Symbol liefert weiterhin na: die Engine hält nur die Kerzen des Charts, und eine plausibel aussehende falsche Zahl wäre schlimmer als gar keine.

Warum liefert request.security() auf den ersten Kerzen na?

Weil noch keine Kerze höherer Zeiteinheit geschlossen ist. Eine 4h-Kerze wird erst auf der Chart-Kerze nach ihrem Schluss lesbar, und genau das verhindert, dass ein Backtest eine noch entstehende Kerze liest. Sobald eine geschlossen ist, wiederholt sich der Wert bis zum Schluss der nächsten.

Wie werden Strategie-Orders in einem Backtest ausgeführt?

Market-Orders werden zur Eröffnung der nächsten Kerze ausgeführt. Stops und Limits entlang der Kerze (Eröffnung, näheres Extrem, entfernteres Extrem, Schluss), und eine Order, über die der Preis springt, wird zur Eröffnung ausgeführt. Provision wird bei jeder Ausführung berechnet, Slippage bei Market- und Stop-Ausführungen, wie in strategy() gesetzt; beide stehen standardmäßig auf null.

Wo laufen Scripts?

Auf dem Chart, in deinem Browser, über die im Chart geladenen Kerzen. Gespeicherte Backtests laufen auf den Servern von Deepwick über bis zu 5.000 Kerzen.