Documentación

Referencia de Deepwick Script

Deepwick Script es el lenguaje de los gráficos y backtests de Deepwick. Lee código de Pine Script v5, así que la mayoría de indicadores y estrategias escritos para TradingView funcionan sin cambios. Esta página recoge todo lo que el motor admite hoy y lo que no.

¿Primera vez en Deepwick? Empieza por la guía paso a paso: Cómo hacer backtesting de una estrategia de Pine Script gratis.

Actualizado: 2026-10-03

Lenguaje

Deepwick Script lee la sintaxis de Pine Script v5. Un script se ejecuta una vez por vela, de la más antigua a la más reciente, y cada variable guarda su historial.

Sintaxis	Qué hace
`x = expr / x := expr`	Declara una variable y reasígnala con :=. Puede llevar delante un tipo opcional (int, float, bool, string, color, series, simple, const, line, label).
`var / varip`	Inicializa una sola vez en la primera vela y conserva el valor entre velas. varip se comporta como var, porque los scripts se ejecutan sobre velas cerradas.
`x[n]`	Operador de historial: el valor de x hace n velas (na antes de la primera vela).
`if / else`	Bloques condicionales, con sangría de cuatro espacios. if también puede usarse como expresión.
`cond ? a : b`	Operador ternario.
`switch`	Selección múltiple, con o sin un valor que comparar.
`for i = a to b [by step]`	Bucle con contador. Admite break y continue.
`while cond`	Bucle mientras se cumpla una condición.
`f(x, y) => expr`	Función definida por el usuario, en una línea o como bloque con sangría cuya última expresión se devuelve. Cada llamada mantiene su propio estado de ta.*, como en Pine.
`[a, b] = f()`	Tuplas: una función puede devolver varios valores, como hacen ta.macd() y ta.bb().
`and / or / not`	Operadores lógicos. Aritméticos: + - * / %; comparación: == != < <= > >=.

Declaraciones

Sintaxis	Qué hace
`indicator(title, shorttitle, overlay, precision)`	Declara un indicador: dibuja en el gráfico y no tiene nada que testear. study() se acepta como alias.
`strategy(title, overlay, initial_capital, default_qty_type, default_qty_value, commission_type, commission_value, slippage, pyramiding)`	Declara una estrategia. Valores por defecto: initial_capital 100000, 1 contrato por orden, comisión 0, slippage 0 ticks, pyramiding 1. Otros argumentos, como process_orders_on_close, se ignoran.

Inputs

Los inputs aparecen junto al editor y en los ajustes del indicador, para cambiarlos sin tocar el código.

Sintaxis	Qué hace
`input.int(defval, title, minval, maxval, step)`	Número entero.
`input.float(defval, title, minval, maxval, step)`	Número decimal.
`input.bool(defval, title)`	Casilla de verificación.
`input.string(defval, title, options)`	Texto, o una lista de opciones.
`input.source(defval, title)`	Una fuente de precio: open, high, low, close, hl2, hlc3, ohlc4 o hlcc4.
`input.color(defval, title)`	Selector de color.
`input(defval, title)`	Input genérico; el tipo sale del valor por defecto.

Datos de la vela y tiempo

Los tiempos van en milisegundos UTC. hour() y las demás funciones de tiempo aceptan un tiempo opcional; hour() acepta además una zona horaria de una lista de desfases fijos, sin horario de verano.

Sintaxis	Qué hace
`open, high, low, close, volume`	Precios y volumen de la vela actual.
`hl2, hlc3, ohlc4, hlcc4`	Promedios de precio habituales.
`bar_index, last_bar_index`	Índice de la vela actual (0 es la más antigua) y de la última.
`time, time_close`	Hora de apertura y de cierre de la vela.
`year, month, weekofyear, dayofmonth, dayofweek, hour, minute, second`	Partes de la fecha de la vela; también se pueden llamar con un tiempo, p. ej. hour(time, "America/New_York"). dayofweek: 1 = domingo … 7 = sábado.
`barstate.isfirst, islast, isnew, isconfirmed, ishistory, isrealtime`	En qué punto del historial está el script.
`timeframe.period, multiplier, isintraday, isdaily, isweekly, ismonthly`	La temporalidad del gráfico.
`syminfo.ticker, tickerid, mintick, pointvalue`	El símbolo del gráfico, su paso de precio y el valor del punto.

Análisis técnico (ta.*)

Cada llamada mantiene su propio estado, como en Pine: dos ta.ema() en líneas distintas son dos medias independientes. El resultado es na hasta que hay velas suficientes.

Sintaxis	Qué hace
`ta.sma(source, length)`	Media móvil simple.
`ta.ema(source, length)`	Media móvil exponencial.
`ta.rma(source, length)`	Media de Wilder, la que usan el RSI y el ATR.
`ta.wma(source, length)`	Media móvil ponderada.
`ta.vwma(source, length)`	Media móvil ponderada por volumen.
`ta.hma(source, length)`	Media móvil de Hull.
`ta.linreg(source, length, offset)`	Valor de la recta de regresión lineal.
`ta.vwap(source)`	Precio medio ponderado por volumen, que se reinicia cada día a las 00:00 UTC.
`ta.rsi(source, length)`	Índice de fuerza relativa, de 0 a 100.
`ta.macd(source, fastlen, slowlen, siglen)`	Devuelve [macd, señal, histograma].
`ta.stoch(source, high, low, length)`	Estocástico %K, de 0 a 100.
`ta.cci(source, length)`	Commodity Channel Index.
`ta.mfi(series, length)`	Money Flow Index.
`ta.wpr(length)`	Williams %R, de -100 a 0.
`ta.dmi(diLength, adxSmoothing)`	Devuelve [+DI, -DI, ADX].
`ta.supertrend(factor, atrPeriod)`	Devuelve [supertrend, dirección]; la dirección es -1 en tendencia alcista y 1 en bajista.
`ta.sar(start, inc, max)`	SAR parabólico.
`ta.mom(source, length)`	Momento: source menos source de hace length velas.
`ta.roc(source, length)`	Tasa de variación, en porcentaje.
`ta.change(source, length)`	Diferencia con hace length velas (1 por defecto).
`ta.tr / ta.tr(handle_na)`	Rango verdadero.
`ta.atr(length)`	Rango verdadero medio (Wilder).
`ta.bb(series, length, mult)`	Bandas de Bollinger: devuelve [media, superior, inferior].
`ta.bbw(series, length, mult)`	Anchura de las Bandas de Bollinger: (superior - inferior) / media.
`ta.kc(series, length, mult)`	Canales de Keltner: devuelve [media, superior, inferior], con una EMA del rango verdadero.
`ta.stdev(source, length, biased)`	Desviación típica.
`ta.variance(source, length, biased)`	Varianza.
`ta.dev(source, length)`	Desviación media absoluta.
`ta.median(source, length)`	Mediana.
`ta.highest(source, length) / ta.highest(length)`	Valor más alto de las últimas length velas (el máximo por defecto).
`ta.lowest(source, length) / ta.lowest(length)`	Valor más bajo de las últimas length velas (el mínimo por defecto).
`ta.highestbars(source, length)`	Desplazamiento hasta el valor más alto: 0 o negativo.
`ta.lowestbars(source, length)`	Desplazamiento hasta el valor más bajo: 0 o negativo.
`ta.rising(source, length)`	Verdadero si source supera cada uno de sus length valores anteriores.
`ta.falling(source, length)`	Verdadero si source está por debajo de cada uno de sus length valores anteriores.
`ta.crossover(source1, source2)`	Verdadero en la vela en la que source1 cruza por encima de source2.
`ta.crossunder(source1, source2)`	Verdadero en la vela en la que source1 cruza por debajo de source2.
`ta.cross(source1, source2)`	Verdadero con un cruce en cualquier sentido.
`ta.pivothigh(source, leftbars, rightbars)`	El precio del pivote alto, conocido rightbars velas después del pivote; na en otro caso. source es opcional (el máximo por defecto).
`ta.pivotlow(source, leftbars, rightbars)`	El precio del pivote bajo, conocido rightbars velas después del pivote; na en otro caso. source es opcional (el mínimo por defecto).
`ta.valuewhen(condition, source, occurrence)`	Valor de source en la ocurrencia número occurrence, contando hacia atrás, en que condition fue verdadera.
`ta.barssince(condition)`	Velas desde la última vez que condition fue verdadera.
`ta.cum(source)`	Suma acumulada desde la primera vela.

Estrategias (strategy.*)

Las órdenes a mercado se ejecutan en la apertura de la vela siguiente. Las stop y limit se ejecutan a lo largo de la vela: apertura, el extremo más cercano a la apertura, el otro extremo y el cierre. Si el precio salta por encima de una orden (gap), se ejecuta en la apertura. La comisión se cobra en cada ejecución; el slippage se aplica a las órdenes a mercado y stop.

Sintaxis	Qué hace
`strategy.entry(id, direction, qty, limit, stop, comment)`	Abre una posición o añade a ella; a mercado salvo que se indique limit o stop.
`strategy.order(id, direction, qty, limit, stop, comment)`	Mismos argumentos que strategy.entry().
`strategy.exit(id, from_entry, qty_percent, profit, limit, loss, stop, comment)`	Take profit y stop loss de una entrada: profit y loss en ticks, limit y stop como precios.
`strategy.close(id, comment, qty_percent)`	Cierra una entrada a mercado en la vela siguiente.
`strategy.close_all(comment)`	Cierra todas las posiciones abiertas.
`strategy.cancel(id) / strategy.cancel_all()`	Cancela órdenes pendientes.
`strategy.position_size, position_avg_price`	Posición actual (positiva larga, negativa corta) y su precio medio.
`strategy.equity, netprofit, openprofit, grossprofit, grossloss, initial_capital`	Cifras de la cuenta.
`strategy.closedtrades, opentrades, wintrades, losstrades`	Número de operaciones.
`strategy.long, strategy.short`	Direcciones.
`strategy.fixed, strategy.cash, strategy.percent_of_equity`	Valores para default_qty_type.
`strategy.commission.percent, cash_per_order, cash_per_contract`	Valores para commission_type.

Gráficos y alertas

Sintaxis	Qué hace
`plot(series, title, color, linewidth, style)`	Dibuja una serie en el gráfico o en un panel.
`plotshape(series, title, style, location, color, text)`	Dibuja una forma en las velas donde series es verdadero.
`plotchar(series, title, char, location, color)`	Dibuja un carácter en las velas donde series es verdadero.
`hline(price, title, color, linestyle)`	Línea horizontal en un nivel fijo.
`fill(plot1, plot2, color)`	Rellena entre dos plots o dos hlines.
`bgcolor(color)`	Colorea el fondo de la vela.
`barcolor(color)`	Colorea la propia vela.
`alertcondition(condition, title, message)`	Declara una condición que puedes convertir en una alerta por email, Telegram, Discord o webhook.
`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. Se aceptan, pero las formas se dibujan a un solo tamaño.

Líneas y cajas

Sintaxis	Qué hace
`line.new(x1, y1, x2, y2, extend, color, style, width)`	Dibuja una línea entre dos índices de vela y dos precios; devuelve su id.
`line.set_x1, set_y1, set_x2, set_y2, set_xy1, set_xy2, set_color, set_style, set_width`	Modifican una línea.
`line.delete(id)`	Elimina una línea.
`box.new(left, top, right, bottom, border_color, bgcolor, extend)`	Dibuja un rectángulo; devuelve su id.
`box.set_left, set_top, set_right, set_bottom, set_bgcolor, set_border_color, set_extend`	Modifican una caja.
`box.delete(id)`	Elimina una caja.
`line.style_, box.style_`	solid, dashed, dotted.
`extend.*`	none, left, right, both.

Matemáticas, textos y colores

Sintaxis	Qué hace
`math.abs, ceil, floor, round(number, precision), sign, sqrt, exp, log, log10, pow(base, exponent)`	Aritmética.
`math.max(...), math.min(...), math.avg(...)`	De cualquier número de valores.
`math.sum(source, length)`	Suma de las últimas length velas.
`math.pi, math.e`	Constantes.
`na, na(x), nz(x, replacement), fixnan(x)`	El valor ausente, la prueba de si lo es, su sustituto y el último valor que no es na.
`int(x), float(x), bool(x)`	Conversiones.
`str.tostring(value, format), str.format(text, ...), str.length(s), str.contains(s, part)`	Textos. str.format sustituye {0}, {1}… por los argumentos.
`color.new(color, transp), color.rgb(red, green, blue, transp)`	Construye un color; transparencia de 0 a 100.
`color.*`	red, green, blue, orange, yellow, purple, aqua, lime, fuchsia, teal, maroon, navy, olive, gray, silver, white, black.

Arrays (array.*)

Sintaxis	Qué hace
`array.new_float, new_int, new_bool, new_string, new_color, new_line, new_box, new_label, new_table(size)`	Crea un array.
`array.get, set, insert, push, pop, shift, unshift`	Leen y modifican elementos.
`array.size, first, last, sum, avg, min, max, stdev`	Tamaño y estadísticas.

Todavía no disponible

Una función que el motor no conoce detiene el script con «Unknown function» y la línea y la columna.

Sintaxis	Qué hace
`request.security()`	Compila, pero devuelve na: los datos de otros símbolos o temporalidades todavía no están disponibles dentro de los scripts.
`label.new(), table.new()`	Todavía no. Las líneas y las cajas sí.
`type, method, import, map., matrix.`	No hay tipos definidos por el usuario, métodos propios, librerías, maps ni matrices.
`strategy.risk.*, trailing stops`	No hay reglas de riesgo ni stops dinámicos (trailing) en strategy.exit().

Preguntas

¿Deepwick Script es lo mismo que Pine Script?

No. Es el motor propio de Deepwick, que lee la sintaxis de Pine Script v5 e implementa las funciones de esta página. La mayoría de indicadores y estrategias de v5 funcionan sin cambios. Deepwick no tiene relación con TradingView; Pine Script es una marca de TradingView, Inc.

¿Puedo ejecutar código de Pine Script v6?

La línea //@version no se comprueba, así que un script de v6 funciona si solo usa lo que aparece en esta página. Lo que solo existe en v6 no está implementado.

¿Deepwick admite request.security()?

Todavía no. La llamada compila, pero devuelve na, así que todo lo que dependa de otro símbolo o temporalidad queda vacío.

¿Cómo se ejecutan las órdenes de una estrategia en el backtest?

Las órdenes a mercado se ejecutan en la apertura de la vela siguiente. Las stop y limit, a lo largo de la vela (apertura, extremo más cercano, extremo más lejano, cierre), y una orden que el precio salta con un gap se ejecuta en la apertura. La comisión se cobra en cada ejecución y el slippage en las órdenes a mercado y stop, según strategy(); ambos son cero por defecto.

¿Dónde se ejecutan los scripts?

En el gráfico, en tu navegador, sobre las velas cargadas en el gráfico. Los backtests guardados se ejecutan en los servidores de Deepwick sobre un máximo de 5.000 velas.