Open sourceMPL-2.0 LibraryPublished 2026-10-12Updated 2026-10-15 · v2Pane

MACD ReLoaded

by KivancOzbilgic · ported by @flosignals-library▲ 0 boosts0 on charts0 comments

"MACD ReLoaded" by KivancOzbilgic, MPL-2.0. Ported to FloScript by FloSignals; modifications under MPL-2.0. Original: MACD ReLoaded (v1.0), read 2026-10-12T16:04:32.865Z; source language v4.

Licence: Mozilla Public License 2.0 (MPL-2.0) — full text. The source is published with it, modifications included, under the same licence.

No cover yet. The author captures one from the chart in the publish sheet.

MACD ReLoaded by KivancOzbilgic, ported from Pine v4. Pane indicator with 3 plots and 7 inputs.

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © KivancOzbilgic


//developer: Gerald Appel
//author: @kivancozbilgic
// ------------------------------------------------------------------------------------------------
// Original author:  KivancOzbilgic
// Original title:   MACD ReLoaded
// Licence:          MPL-2.0 (the header above is the original notice, kept verbatim)
// Pine version:     4
// Fetched:          2026-10-12
// Ported to FloScript by FloSignals; modifications under MPL-2.0.
// Converter:        @flosignals/floscript 0.1.0, strict mode, score 100/100
// ------------------------------------------------------------------------------------------------
//@floscript=1
//@version=5
// Converted by the FloScript converter from a Pine-compatible v4 source.

indicator("MACD ReLoaded", "MACDRe", overlay=false, timeframe="")
src = input(close, title="Source")
length = input.int(12, "Short Moving Average Length", minval=1)
length1 = input.int(26, "Long Moving Average Length", minval=1)
length2 = input.int(9, "Trigger Length", minval=1)
T3a1 = input.float(0.7, "TILLSON T3 Volume Factor", step=0.1)
showhistogram = input.bool(title="Show MACD Histogram?", defval=true)

mav = input.string(title="Moving Average Type", defval="VAR", options=["SMA", "EMA", "WMA", "DEMA", "TMA", "VAR", "WWMA", "ZLEMA", "TSF", "HULL", "TILL"])
Var_Func(src, length) =>
    valpha = 2 / (length + 1)
    vud1 = src > src[1] ? src - src[1] : 0
    vdd1 = src < src[1] ? src[1] - src : 0
    vUD = math.sum(vud1, 9)
    vDD = math.sum(vdd1, 9)
    vCMO = nz((vUD - vDD) / (vUD + vDD))
    VAR = 0.0
    VAR := nz(valpha * math.abs(vCMO) * src) + (1 - valpha * math.abs(vCMO)) * nz(VAR[1])
VAR = Var_Func(src, length)
DEMA = 2 * ta.ema(src, length) - ta.ema(ta.ema(src, length), length)
Wwma_Func(src, length) =>
    wwalpha = 1 / length
    WWMA = 0.0
    WWMA := wwalpha * src + (1 - wwalpha) * nz(WWMA[1])
WWMA = Wwma_Func(src, length)
Zlema_Func(src, length) =>
    zxLag = length / 2 == math.round(length / 2) ? length / 2 : (length - 1) / 2
    zxEMAData = src + (src - src[zxLag])
    ZLEMA = ta.ema(zxEMAData, length)
ZLEMA = Zlema_Func(src, length)
Tsf_Func(src, length) =>
    lrc = ta.linreg(src, length, 0)
    lrc1 = ta.linreg(src, length, 1)
    lrs = lrc - lrc1
    TSF = ta.linreg(src, length, 0) + lrs
TSF = Tsf_Func(src, length)
HMA = ta.wma(2 * ta.wma(src, length / 2) - ta.wma(src, length), math.round(math.sqrt(length)))
T3e1 = ta.ema(src, length)
T3e2 = ta.ema(T3e1, length)
T3e3 = ta.ema(T3e2, length)
T3e4 = ta.ema(T3e3, length)
T3e5 = ta.ema(T3e4, length)
T3e6 = ta.ema(T3e5, length)
T3c1 = -T3a1 * T3a1 * T3a1
T3c2 = 3 * T3a1 * T3a1 + 3 * T3a1 * T3a1 * T3a1
T3c3 = -6 * T3a1 * T3a1 - 3 * T3a1 - 3 * T3a1 * T3a1 * T3a1
T3c4 = 1 + 3 * T3a1 + T3a1 * T3a1 * T3a1 + 3 * T3a1 * T3a1
T3 = T3c1 * T3e6 + T3c2 * T3e5 + T3c3 * T3e4 + T3c4 * T3e3

getMA(src, length) =>
    ma = 0.0
    if mav == "SMA"
        ma := ta.sma(src, length)
        ma

    if mav == "EMA"
        ma := ta.ema(src, length)
        ma

    if mav == "WMA"
        ma := ta.wma(src, length)
        ma

    if mav == "DEMA"
        ma := DEMA
        ma

    if mav == "TMA"
        ma := ta.sma(ta.sma(src, math.ceil(length / 2)), math.floor(length / 2) + 1)
        ma

    if mav == "VAR"
        ma := VAR
        ma

    if mav == "WWMA"
        ma := WWMA
        ma

    if mav == "ZLEMA"
        ma := ZLEMA
        ma

    if mav == "TSF"
        ma := TSF
        ma

    if mav == "HULL"
        ma := HMA
        ma

    if mav == "TILL"
        ma := T3
        ma
    ma

MA12 = getMA(src, length)

Var_Func1(src, length1) =>
    valpha1 = 2 / (length1 + 1)
    vud11 = src > src[1] ? src - src[1] : 0
    vdd11 = src < src[1] ? src[1] - src : 0
    vUD1 = math.sum(vud11, 9)
    vDD1 = math.sum(vdd11, 9)
    vCMO1 = nz((vUD1 - vDD1) / (vUD1 + vDD1))
    VAR1 = 0.0
    VAR1 := nz(valpha1 * math.abs(vCMO1) * src) + (1 - valpha1 * math.abs(vCMO1)) * nz(VAR1[1])
VAR1 = Var_Func1(src, length1)
DEMA1 = 2 * ta.ema(src, length1) - ta.ema(ta.ema(src, length1), length1)
Wwma_Func1(src, length1) =>
    wwalpha1 = 1 / length1
    WWMA1 = 0.0
    WWMA1 := wwalpha1 * src + (1 - wwalpha1) * nz(WWMA1[1])
WWMA1 = Wwma_Func1(src, length1)
Zlema_Func1(src, length1) =>
    zxLag1 = length1 / 2 == math.round(length1 / 2) ? length1 / 2 : (length1 - 1) / 2
    zxEMAData1 = src + (src - src[zxLag1])
    ZLEMA1 = ta.ema(zxEMAData1, length1)
ZLEMA1 = Zlema_Func1(src, length1)
Tsf_Func1(src, length1) =>
    lrc1 = ta.linreg(src, length1, 0)
    lrc11 = ta.linreg(src, length1, 1)
    lrs1 = lrc1 - lrc11
    TSF1 = ta.linreg(src, length1, 0) + lrs1
TSF1 = Tsf_Func1(src, length1)
HMA1 = ta.wma(2 * ta.wma(src, length1 / 2) - ta.wma(src, length1), math.round(math.sqrt(length1)))
T3e11 = ta.ema(src, length1)
T3e21 = ta.ema(T3e11, length1)
T3e31 = ta.ema(T3e21, length1)
T3e41 = ta.ema(T3e31, length1)
T3e51 = ta.ema(T3e41, length1)
T3e61 = ta.ema(T3e51, length1)
T3c11 = -T3a1 * T3a1 * T3a1
T3c21 = 3 * T3a1 * T3a1 + 3 * T3a1 * T3a1 * T3a1
T3c31 = -6 * T3a1 * T3a1 - 3 * T3a1 - 3 * T3a1 * T3a1 * T3a1
T3c41 = 1 + 3 * T3a1 + T3a1 * T3a1 * T3a1 + 3 * T3a1 * T3a1
T31 = T3c11 * T3e61 + T3c21 * T3e51 + T3c31 * T3e41 + T3c41 * T3e31

getMA1(src, length1) =>
    ma1 = 0.0
    if mav == "SMA"
        ma1 := ta.sma(src, length1)
        ma1

    if mav == "EMA"
        ma1 := ta.ema(src, length1)
        ma1

    if mav == "WMA"
        ma1 := ta.wma(src, length1)
        ma1

    if mav == "DEMA"
        ma1 := DEMA1
        ma1

    if mav == "TMA"
        ma1 := ta.sma(ta.sma(src, math.ceil(length1 / 2)), math.floor(length1 / 2) + 1)
        ma1

    if mav == "VAR"
        ma1 := VAR1
        ma1

    if mav == "WWMA"
        ma1 := WWMA1
        ma1

    if mav == "ZLEMA"
        ma1 := ZLEMA1
        ma1

    if mav == "TSF"
        ma1 := TSF1
        ma1

    if mav == "HULL"
        ma1 := HMA1
        ma1

    if mav == "TILL"
        ma1 := T31
        ma1
    ma1

MA26 = getMA1(src, length1)

src2 = MA12 - MA26

Var_Func2(src2, length2) =>
    valpha2 = 2 / (length2 + 1)
    vud12 = src2 > src2[1] ? src2 - src2[1] : 0
    vdd12 = src2 < src2[1] ? src2[1] - src2 : 0
    vUD2 = math.sum(vud12, 9)
    vDD2 = math.sum(vdd12, 9)
    vCMO2 = nz((vUD2 - vDD2) / (vUD2 + vDD2))
    VAR2 = 0.0
    VAR2 := nz(valpha2 * math.abs(vCMO2) * src2) + (1 - valpha2 * math.abs(vCMO2)) * nz(VAR2[1])
VAR2 = Var_Func2(src2, length2)
DEMA2 = 2 * ta.ema(src2, length2) - ta.ema(ta.ema(src2, length2), length2)
Wwma_Func2(src2, length2) =>
    wwalpha2 = 1 / length2
    WWMA2 = 0.0
    WWMA2 := wwalpha2 * src2 + (1 - wwalpha2) * nz(WWMA2[1])
WWMA2 = Wwma_Func2(src2, length2)
Zlema_Func2(src2, length2) =>
    zxLag2 = length2 / 2 == math.round(length2 / 2) ? length2 / 2 : (length2 - 1) / 2
    zxEMAData2 = src2 + (src2 - src2[zxLag2])
    ZLEMA2 = ta.ema(zxEMAData2, length2)
ZLEMA2 = Zlema_Func2(src2, length2)
Tsf_Func2(src2, length2) =>
    lrc2 = ta.linreg(src2, length2, 0)
    lrc12 = ta.linreg(src2, length2, 1)
    lrs2 = lrc2 - lrc12
    TSF2 = ta.linreg(src2, length2, 0) + lrs2
TSF2 = Tsf_Func2(src2, length2)
HMA2 = ta.wma(2 * ta.wma(src2, length2 / 2) - ta.wma(src2, length2), math.round(math.sqrt(length2)))
T3e12 = ta.ema(src2, length2)
T3e22 = ta.ema(T3e12, length2)
T3e32 = ta.ema(T3e22, length2)
T3e42 = ta.ema(T3e32, length2)
T3e52 = ta.ema(T3e42, length2)
T3e62 = ta.ema(T3e52, length2)
T3c12 = -T3a1 * T3a1 * T3a1
T3c22 = 3 * T3a1 * T3a1 + 3 * T3a1 * T3a1 * T3a1
T3c32 = -6 * T3a1 * T3a1 - 3 * T3a1 - 3 * T3a1 * T3a1 * T3a1
T3c42 = 1 + 3 * T3a1 + T3a1 * T3a1 * T3a1 + 3 * T3a1 * T3a1
T32 = T3c12 * T3e62 + T3c22 * T3e52 + T3c32 * T3e42 + T3c42 * T3e32

getMA2(src2, length2) =>
    ma2 = 0.0
    if mav == "SMA"
        ma2 := ta.sma(src2, length2)
        ma2

    if mav == "EMA"
        ma2 := ta.ema(src2, length2)
        ma2

    if mav == "WMA"
        ma2 := ta.wma(src2, length2)
        ma2

    if mav == "DEMA"
        ma2 := DEMA2
        ma2

    if mav == "TMA"
        ma2 := ta.sma(ta.sma(src2, math.ceil(length2 / 2)), math.floor(length2 / 2) + 1)
        ma2

    if mav == "VAR"
        ma2 := VAR2
        ma2

    if mav == "WWMA"
        ma2 := WWMA2
        ma2

    if mav == "ZLEMA"
        ma2 := ZLEMA2
        ma2

    if mav == "TSF"
        ma2 := TSF2
        ma2

    if mav == "HULL"
        ma2 := HMA2
        ma2

    if mav == "TILL"
        ma2 := T32
        ma2
    ma2

MATR = getMA2(MA12 - MA26, length2)
hist = src2 - MATR
plot(showhistogram ? hist : na, title="Histogram", style=plot.style_columns, color=hist >= 0 ? (hist[1] < hist ? color.lime : #B2DFDB) : hist[1] < hist ? #FFCDD2 : #EF5350)
plot(src2, title="MACDRe", color=#426BE6, linewidth=2)
plot(MATR, title="TRIGGER", color=#E60000, linewidth=2)

This file is under the Mozilla Public License 2.0; it is a port of the original by KivancOzbilgic, with the original licence header kept and the changes made for FloScript noted in the file.

Comments (0)

No comments yet. Members can leave one.

Disclaimer. Scripts are written and published by members, or ported by FloSignals from open-source originals, and are their authors' own work and opinion. FloSignals does not review them for correctness and nothing in a script is financial advice or a recommendation to buy or sell anything — read the Risk Disclaimer. Posting here is under the Community Rules; a script that is not the poster's to post can be reported as the Copyright & Takedowns page says.