1 of 100

FTO Indicators Docs

Overview

Welcome to the documentation for creating custom indicators in Forex Tester Online (FTO).

This guide is designed to help developers and strategy testers understand the structure, lifecycle, and capabilities of custom scripts written for FTO. You’ll learn how to set up your environment, build your own indicators, and access key platform features via the available API.

📌 What You’ll Find Here

Quick Guide Get started with setting up your development environment and creating your first indicator using a simple Moving Average example.
Understand the lifecycle of an indicator through core functions like Init, Calculate, Done, and more.
Learn how to create and manage visible buffers to display your indicator’s values on the chart.
Understand how to retrieve bar data, price arrays, and time series to power your custom logic.
Customize the behavior and appearance of indicators through parameters and configuration blocks.
Use external inputs to make your indicators dynamic and easily customizable by users.
Retrieve metadata about the active instrument, such as symbol name, point size, and tick value.
Use the FTODate structure to manage time-based logic and align calculations with bar timestamps.
Explore helper functions and additional features available to streamline development.

This documentation is for:

Developers building and debugging trading indicators
Algorithmic traders backtesting and optimizing their strategies
Power users looking to customize and extend FTO’s capabilities

Start with the guide and move on to the to see how it all works in action.

Indicators: your trading super-vision

A quick introduction: what they do, why traders use them, and how they can help you spot market trends and signals.

If strategies are the brain and hands of trading, indicators are the eyes.They don’t open or close trades for you, but they help you see the market more clearly — drawing lines, showing averages, or highlighting trends. Think of them as your personal set of night-vision goggles: they light up what’s happening on the chart so you can decide what to do next (or let your strategy decide).In short:

Strategies = decision-makers (they trade)
Indicators = signal-givers (they show the picture)

With indicators, you can track momentum, spot entry points, or just make your charts look way cooler. Ready to add some trading super-vision? Let’s dive in!\

Set up indicator

This page shows you how to set up your environment for writing custom indicators in FTO. Think of it as laying out your pencils before sketching.

This guide shows you how to prepare your environment so you can start writing your own custom indicator for FTO.

To use the custom indicator API, you’ll first need an example to work from. Don’t worry, we’ve got you covered — you can either browse a few ready-made examples here, or just grab the suggested starter file below. Think of it as your “Hello World” for indicators.

3KB

moving-average.zip

archive

Open

Why start with an example?

Jumping into custom indicators from scratch can feel like walking into a movie halfway through — you’ll miss the setup.

That’s why we suggest starting with a ready-made example:

You see the basic structure in action
You avoid silly mistakes on the first steps
You can tweak and play instead of reinventing the wheel

It’s faster, safer, and way more fun. Once you’re comfortable, you can always build your own indicator logic from scratch.

Open the example project in Cursor (or any IDE you like — but honestly, Cursor makes life easier).

Next, click the little terminal icon (see Picture #1) — it’s that black box where all the behind-the-scenes magic happens.

Now run:

Once the dependencies are in place, it’s time to build your project.

Pop open your terminal (still in that same black box of magic) and run:

This will compile your indicator into a nice, ready-to-use .js file.

Think of it as baking the dough you just mixed — after this step, you’ll actually have bread instead of just flour and water.

If everything goes well, you should see a fresh build appear in your dist folder. That’s your indicator, ready for action!

After building, you’ll see a fresh file named my-indicator-project.js appear in your dist folder. That’s your ready-to-use indicator, hot and shiny.

Curious about the next step? Head over to the to learn how to bring your indicator into FTO and watch it in action on a chart.

Upload indicator to FTO

This guide shows you how to take your freshly built indicator and bring it into Forex Tester Online.

f you’ve already run the npm run build command and everything went smoothly, you should now have a file called my-indicator-project.js sitting inside your dist folder. That’s the one we’re going to upload.

Open FTO, head over to your project, and in the Indicators tab hit Upload Indicator. Then just drag-and-drop your .js file into the upload area or select it manually (see Picture #1 and Picture #2).

Pro tip: Treat this file like your golden ticket — once it’s in FTO, you’ll finally get to see your indicator in action.

After uploading, your indicator will show up in the “My Indicators” dropdown menu (see Picture #3).

From here, just pick it, hit Apply, and watch it come alive on your chart.

Pro tip: If you don’t see it right away, double-check that you uploaded the .js file from your dist folder — that’s the only one FTO recognizes.

Tutorial: Create indicator with Cursor IDE

Introduction

Want to build your own indicator from scratch? You’re in the right place.

This tutorial walks you through creating a custom indicator using Cursor IDE.

Don’t worry if it sounds complicated — we’ll go step by step, with screenshots and examples. By the end, you’ll have your very own indicator running in FTO, powered by Cursor’s AI.

Please note that Cursor is a paid IDE, but it has a free version, the free version is limited to 50 requests and 2000 completions total.

Step 1: Install Cursor and set up the project

Get your tools ready — install Cursor IDE and prepare your project so you’re set to start building indicators.

First things first — you’ll need Cursor IDE.

If you don’t have it yet, go ahead and install it (full setup guide is right here).

Once Cursor is ready, set up your project.

If you’re new to the FTO Indicator API, don’t worry — that same guide also covers how to prep your environment so you’re good to go.

Step 2: Apply Cursor Rules

Teach Cursor your custom rules so it knows how to handle indicators smarter and faster.

Cursor has a Rules feature — basically a way to teach the AI how you want it to behave when generating code.

Think of it as house rules for a guest: “shoes off, fridge is fair game, don’t touch the cat.”

By setting up rules that explain how indicators work in FTO, you’re giving Cursor the context it needs to create consistent, accurate code. No more random guesses — just well-informed suggestions.

To set global rules:

Click the Settings icon (see Picture #1)

From the Settings menu, click on Rules (see Picture #2).

This is where you’ll drop in the custom guidelines that will teach Cursor how to behave when working with your indicators.

Think of this as setting the ground rules before starting a board game — once everyone knows the rules, things run smoother (and there’s less arguing).\

In the User Rules field (see Picture #3), paste in the contents of the file called Rules.txt.

That’s your playbook — the set of instructions that teaches Cursor how to “think” when working with indicators in FTO.

Pro tip: It’s like giving your AI a cheat sheet before the test. The more detail you put in here, the less Cursor will bother you later with questions.

Step 3: Upload FTO indicator documentation to Cursor

In this step, we’ll give Cursor its “textbook” — the official FTO indicator documentation.

Now that Cursor knows the rules, let’s give it the actual manual.

By uploading the official FTO indicator documentation, Cursor will have a knowledge base it can use to generate better code for you. No more guessing, no more “hmm, what does this method do?” — Cursor will actually know.

Here’s how to do it:

Click the Settings icon in the top right corner of Cursor IDE (see Picture #1).
Think of this step as handing Cursor the instruction booklet — without it, it’s like trying to build IKEA furniture without the tiny hex key.

2. Next stop: Features.

Think of it as the secret drawer where all the cool settings live. Click on Features in the left sidebar — that’s where you’ll find everything you need to feed Cursor the right docs. (See Picture #2.)

Almost there! Scroll down the Features page until you spot the Docs section — that’s your gateway to feeding Cursor some serious brain food. (See Picture #3.)

Time to feed Cursor some serious knowledge! Hit the “Add new doc” button and paste this link: https://fto-2.gitbook.io/fto-indicators-docs.
This tells Cursor, “Here’s everything you need to know about indicators in FTO — study up!” (See Picture #4.)

Once you add the link, Cursor will take a moment to index the docs. Grab a coffee (or stretch your fingers) while it works.

After that, Cursor will have all the smarts it needs to reference the documentation and help you craft your shiny new indicators like a pro.

Step 4: Getting familiar with Cursor

Get to know the Cursor AI panel — the control room for your indicator magic. We’ll guide you through its modes, buttons, and little tricks to speed up your workflow (and keep things fun).

To open the Cursor AI panel, press Ctrl+L or click the icon in the top right corner of the Cursor IDE (see Picture #1).

This will open the chat interface — your command center for talking to the AI (yes, it listens — and it’s surprisingly helpful). In Cursor version 1.3.9, there are three available modes: Agent, Ask, and Background (see Picture #2).

Choosing Your AI Mode

Each one plays a different role in your coding adventure.

Agent Mode

Think of it as your AI pair programmer. It sees your project, suggests edits, and you can thumbs-up or thumbs-down its ideas like a benevolent overlord.

Ask Mode

Your Q&A corner. Need to know how a moving average works? Why your code screams in red? Ask away.

Background Mode

This one works behind the scenes. Cursor quietly watches your code and offers suggestions only when relevant. It won’t interrupt you — unless it has something genuinely useful to say. The real magic? You can feed Cursor extra context from your files or docs — like giving it caffeine for smarter replies.

For now, select Agent Mode.

Next to the mode selector, you’ll also see an AI model dropdown. Just leave it on Auto for now — let Cursor pick the right brain for the job (see Picture #3).

Quick warning:

Skip Gemini. Cursor and Gemini aren’t exactly BFFs — context issues, buggy behavior, you name it. If you do want to pick a model manually, stick to Claude or OpenAI. Cursor was trained to jam with them, and the experience is smooth.

Once you’ve taken this quick tour, you’re all set to dive into building your first custom indicator. Next step — sleeves up (real or metaphorical) and let’s create something awesome for FTO.\

Step 5: Start building

Alright, the warm-up is done — now it’s time to get your hands dirty (figuratively).

This is where we actually start writing code for your custom indicator.

Before we dive into coding, make sure your setup is ready to roll. You’ll need access to the FTO Indicator API to make things work smoothly.

Not there yet? No problem — check out the setup guide first, get your environment prepped, and then come back here. It’s a quick read and will save you a ton of head-scratching later.

For this example, we’ll let Cursor do some of the heavy lifting: we’ll ask it to create the On Balance Volume (OBV) indicator for us. We’ll start simple — with a completely empty file — so you can see the process from scratch. Later, when you’re more comfortable, you can speed things up by using some of our pre-built indicator foundations (you’ll find them in this section).

Think of this as baking your first cake from flour and sugar — once you’ve got the hang of it, you can use ready-made mixes to save time.

When we asked Cursor to create the OBV indicator, we didn’t just say “do it.” We gave it some context — included the FTO Indicator documentation and the we set up earlier. In the screenshot (Picture #1), you can see exactly which parts of the documentation Cursor decided to use. It’s like watching your AI buddy flip through the manual before giving you the best answer.

In the result, we got code below

The current logic looks solid so far, but there’s a catch: it’s locked to using the Close price only. That’s a bit limiting, right? What if someone wants to use the High, Low, or Open price instead?

No worries — let’s get Cursor to step up its game. We’ll ask it to tweak the code so users can pick their preferred price type. (See Picture #2 to follow along.)

After we asked Cursor to improve the OBV indicator, here’s what it came up with in its second response.

This version lets users choose the price type instead of being stuck with the Close price — nice upgrade! (See below.)

With that new parameter and internal method added, Cursor gives us a neat bonus: a dropdown menu for choosing the price type.

No more hardcoded Close price — now you can pick what you need right from the list. (See Picture #3 — that’s your shiny new option selector!)

And that’s it — with just two simple requests, Cursor delivered a fully working OBV indicator.

All it took was a proper setup, some clear , and a bit of documentation magic to give it the right context.

Not bad for a few clicks, right? Less typing, more building.

Recommendations

Some quick tips to get the most out of Cursor and your docs

Remember the documentation we uploaded back in Step 3? Now it’s time to make Cursor use it like a pro.

Here’s how:

Switch Cursor to Ask Mode (it’s the one for questions and answers).
In your request, type @ and choose Docs from the drop-down menu (see Picture #1).

This tells Cursor, “Hey, use the official FTO indicator docs for this answer.”

It’s like giving your AI a quick shot of espresso before it writes code — smarter, faster, and right on point.

From that drop-down menu, choose FTO Indicator documentation — the same one we uploaded back in Step 3 (see Picture #2).

This basically tells Cursor, “Hey, use the official playbook for this answer.” It’s like handing your AI the cheat sheet before an exam — fewer mistakes, better results.

Cursor needs to know which file to use for your indicator. You can simply drag and drop it straight from the Explorer panel (on the left) into the chat window, or use the @ menu, scroll down to Files & Folders, and select it from the list (see Picture #3). It’s like pointing Cursor to the right canvas before asking it to paint — now it knows exactly where to put the code.

Once you’ve selected the docs and the right file, Cursor has everything it needs to work its magic. From here, it’s just you, the AI, and some clean indicator-building fun. Time to let the code flow!

Tutorial: Open and upload indicator

Ready to see your hard work come alive? This tutorial shows you how to open your indicator project and upload it into Forex Tester Online so you can test it in action.

1. Download and Install Cursor

First, grab the Cursor editor from cursor.com/downloads.

Run the installer and, when it asks about options, tick all the checkboxes — trust us, you’ll want those extras (see Picture #1).

Think of it like ordering pizza with all the toppings. The more boxes you check, the more powerful Cursor becomes.

2. Install Node.js and Get the Example Project

Next up, you’ll need Node.js. If you don’t already have it, grab it here: nodejs.org.

Run the installer and follow the steps — nothing fancy.

Once Node.js is ready, download the indicator example archive we’ve provided below and extract it to a convenient spot. Desktop, Downloads — anywhere you’ll remember.

Tip: Keep it somewhere easy to find — we’ll open it in Cursor soon.

Once you’ve unzipped the archive, open the Moving Average folder.

Inside, you’ll find another folder called custom_indicator — that’s where the action is.

Open it with Cursor (see Picture #2 and #3).

Tip: If you see those folders exactly as described, you’re in the right place. Cursor is now ready to load your project.

If a pop-up appears saying something like “Do you trust the authors?”, don’t panic. It’s just Cursor being cautious.

Click “Yes, I trust the authors” — this simply lets the IDE know it’s safe to open the files.

Tip: This is a normal step whenever you open a project for the first time. Cursor just wants to make sure you’re cool with the code you’re about to run.

Next, click the little terminal icon (see Picture #5) — it’s your gateway to the behind-the-scenes magic. Once it’s open, type this command and hit Enter:

This will download and set up everything your indicator needs to run. Think of it as unpacking your toolbox before you start building.

Tip: If your screen starts showing a bunch of green and white text, you’re doing great — Cursor is fetching all the right pieces.

Once the dependencies are installed, it’s showtime — open the index.ts file and start coding your indicator. This is your playground: add logic, tweak parameters, and let your creativity flow. When you’re happy with your code, it’s time to turn it into something FTO can actually use.

Open the terminal again and run:

Once the build is complete, you’ll see a shiny new file appear in your dist folder called my-indicator-project.js (or whatever name you gave it). This is your ready-to-use indicator — the one you’ll upload into Forex Tester Online.

Tip: Don’t move or rename it yet; FTO expects it just like this when you upload.

Upload this file to the FTO (Picture #6 and #7).

Once you’ve uploaded the file, your indicator will appear in the “My Indicators” dropdown menu (see Picture #8).

From here, it’s just a click away: pick your indicator, apply it, and watch it show up on your chart.

That’s a wrap!

You’ve gone from setting up Cursor to building, uploading, and running your own custom indicator in Forex Tester Online. Now you know how to prepare your environment, guide the AI, and see your work come to life on a chart. Keep experimenting, keep refining, and if you ever get stuck, teams like are there to help. Build more, debug less, and enjoy the process!

Tutorial: Moving Average

Learn how to create and run a simple Moving Average indicator in FTO — perfect for getting started with custom indicators.

Ready to create your first custom indicator? Let’s start with a classic: the Moving Average.

In this tutorial, we’ll walk step by step through building, coding, and running this popular indicator in FTO.

Don’t worry — even if you’re new to indicators, this one’s a great warm-up. By the end, you’ll have a working Moving Average ready to test and tweak on your charts.

To see how things work in practice, start by downloading the archive with the indicator example.

Once it’s on your computer, open it in any IDE you like — but we highly recommend Cursor IDE for the smoothest experience.

For more details on how to open it in Cursor IDE, you can refer to this .

You can download the archive of Moving Average from here

3KB

moving-average.zip

archive

Open

How Custom Indicators Are Built

Every custom indicator in FTO starts with a simple but powerful idea: extend the IndicatorImplementation class from the forex-tester-custom-indicator-api library.

This class gives you all the building blocks you need — methods, structures, and tools — so you can focus on your logic instead of reinventing the wheel.

You can see a working version of this in action in the Moving Average example, which we described earlier in the section. It’s a great place to peek at the code and understand how everything fits together.

Every custom indicator can have its own set of adjustable parameters — things like periods, colors, or calculation methods.

These parameters are defined using the class, which handles different types (numbers, booleans, lists, etc.) and makes them easy to edit.

When you add or edit your indicator in FTO, these parameters will appear in a user-friendly window where you (or your users) can tweak the settings to get just the right behavior.

Think of it as the dashboard for your indicator — all the knobs and switches in one place.

For this, they need to be registered in the function.

Defining parameters is only half the story — to actually use them in your indicator, they need to be registered inside the function. This is where you “introduce” your parameters to FTO so they’ll show up in the indicator settings window.

Without registration, your parameters will just sit quietly in the code, never making it to the user interface.

Think of Init as the guest list at a party — if you don’t put your parameter on the list, it won’t get through the door.

You can see the methods for registering parameters in the

All the methods you’ll need to register your parameters live in the section of the API.

That’s the place where FTO tells you: “Here’s how to make your parameters visible in the UI and ready for users to tweak.”

So whenever you’re setting up parameters in the Init function, just look back at those definitions — they’re your cheat sheet for getting everything hooked up the right way.

Tip: Without registration, parameters stay hidden in the code. With registration, they become clickable, adjustable settings in the indicator window.

are the backstage crew of your indicator.

They’re used to store all those calculated values and then display them as lines, histograms, or other visuals right on your chart.

Think of them as the buckets where your indicator keeps its data before painting it onto the screen.

No buffers = no output. With buffers, your calculations finally become visible magic on the chart.

Buffers need to be both declared as class fields and initialized inside the function.

Creating buffers is just the start — now you need to tell FTO how many buffers will actually show up on the chart, and then bind each one by its index (starting from 0).

Each index must be unique, like seat numbers in a cinema.

In this example, we only need one buffer, so the setup looks like this:

IndicatorBuffers(1) → tells FTO, “I’ve got one buffer to draw.”
SetIndexBuffer(0, this.SSMA) → assigns our buffer SSMA to slot #0 on the chart.

Tip: If you ever add more buffers later (say, for multiple lines), just increase the number in IndicatorBuffers() and assign each one to its own index.

Each registered buffer isn’t just a data bucket — you can also how it’s displayed on the chart.

For example:

SetIndexLabel(0, "MA") → gives your buffer a friendly name (“MA”) so it shows up in the legend.
SetIndexStyle(...) → sets how it looks: here it’s a solid red line with thickness 1.
SetIndexDrawBegin(...) → defines the point on the chart where drawing should start (usually after enough data has been collected).

Tip: Don’t be afraid to play with colors, line styles, and labels. It’s your indicator — make it not only useful but also easy to read at a glance.

Inside the function, you can use a handy setting called . By default, FTO calculates each buffer index only once to save resources. That’s efficient, but sometimes it means your indicator won’t be as accurate as you’d like.

If your calculations aren’t too heavy for the processor, we recommend always enabling this option. It ensures your indicator updates on every tick, keeping results fresh and reliable.

Tip: Think of it as “live mode” for your indicator — better accuracy in exchange for a tiny bit more CPU work.

Every indicator deserves an identity. With ., you set the name that will show up in the indicator settings window and the context menu.

Think of it as the little nametag your indicator wears — something short, clear, and easy to recognize when you’re scrolling through the list.

Tip: Keep it simple (like “Moving Average” or “OBV”) so you instantly know what it is at a glance.

By default, some indicators want to open their own little subwindow under the main chart. But for a Moving Average, it makes much more sense to see it directly on the main chart, hugging the price candles where it belongs.

That’s where comes in — it tells FTO exactly where to draw your indicator. In this case, we point it to the main chart so the Moving Average is right there in the action.

Tip: If you’re building other indicators (like oscillators), you can send them to their own window instead. For Moving Average, keep it on the main chart for the clearest view.

Sometimes indicators calculate values that are just 0 — and honestly, those don’t tell us much. With , you can tell FTO not to draw these points at all.

That way, the chart stays clean, without random flat lines cluttering your view.

Tip: Think of it like editing out background noise from a song — you only keep the meaningful parts, so the final output looks and sounds better.

At the heart of every custom indicator is the function. This is where the real action happens — all the math, logic, and updates take place here on each tick.

Sometimes you want your indicator to react when the user changes its settings — that’s where the method comes in.

This method lets you add custom logic that runs right after parameters are updated. For example, in the Moving Average indicator it’s used to handle the horizontal shift, so the line moves correctly on the chart when the shift value changes.

OnParamsChange is especially handy if your indicator uses custom objects or needs to redraw elements whenever a parameter is tweaked.

Tip: Think of it as your indicator’s “refresh button” — it makes sure the chart always reflects the latest settings the user has chosen.

And there you have it — you’ve just built and understood your first custom indicator: the Moving Average.

From setting up parameters and buffers to configuring styles and handling recalculations, you now know the essential steps behind making an indicator come alive in FTO.

This is a solid foundation — once you’ve mastered the Moving Average, you’re ready to experiment, tweak, and create even more powerful custom tools for your trading.

Download indicator examples

Not sure where to start? No worries — we’ve prepared a few ready-made indicator examples for you. Think of them as training wheels: you can try them out are indicator examples you can download

Below you’ll find three example files — grab them, test them in FTO, and use them as a base for your custom indicators.

3KB

moving-average.zip

archive

Open

2KB

indicator-skeleton.zip

archive

Open

2KB

empty-indicator.zip

archive

Open

Built-in indicators

Looking for ready-made implementations of common indicators (ATR, MACD, Supertrend, and others)? Browse the full catalog with downloads and source code in Built-in indicators.

Indicator examples

Ready-made examples of built-in and starter indicators — source code, downloads, and quick reference for each example.

This section collects downloadable indicator examples with source code. Use them as starting points, reference implementations, or copy-paste templates when building your own indicators.

Each page follows the same structure:

What it does — short description and when to use it
Download — ZIP archive ready to open in your IDE and upload to FTO
Source code — key parts of the implementation
Parameters — configurable options (if any)
See also — links to API docs and tutorials

Example

Description

For the full catalog of built-in FTO indicators (ATR, MACD, Bollinger Bands, and more), see . To add a new starter example, copy and follow the checklist inside.

Download the ZIP from the example page.
Unpack and open the project in (recommended) or any IDE.
Build and upload to FTO — see .
Tweak parameters and logic for your use case.

For a guided walkthrough of the Moving Average, see .

Prepare the indicator project and export as .zip into .
Copy to your-indicator-name.md (kebab-case filename).
Fill in all sections and add the page to under Indicator Examples.

Moving Average

Indicator skeleton

Empty indicator

Built-in indicators

Catalog of built-in FTO indicator examples — download ready-made projects, explore source code, and use them as reference implementations.

This section lists ready-made built-in indicators shipped as downloadable ZIP archives. Each page includes a short overview, a download link, and source code you can study or adapt.

Use them when you need a working reference for a specific indicator type rather than starting from an empty template.

Indicator

Description

ATR

ATR (Average True Range) built-in indicator — download the project and explore volatility measurement on the chart.

Average True Range (ATR) measures market volatility by averaging the true range over a selected period. Traders use it for stop placement, position sizing, and volatility filters.

Bollinger Bands

Bollinger Bands built-in indicator — download the project and explore price channels based on standard deviation.

Bollinger Bands plot upper and lower bands around a moving average using standard deviation. They help identify volatility expansion, contraction, and potential mean-reversion zones.

CCI

CCI (Commodity Channel Index) built-in indicator — download the project and explore cyclical overbought/oversold levels.

The Commodity Channel Index (CCI) is an oscillator that compares the current price to its statistical average. It is often used to spot overbought and oversold conditions and short-term reversals.

Doji

Doji built-in indicator — download the project and explore Doji candlestick pattern detection on the chart.

The Doji indicator highlights candlesticks where open and close are nearly equal, signaling indecision. Useful for pattern-based entries and confluence with other signals.

Engulfing Bar

Engulfing Bar built-in indicator — download the project and explore bullish and bearish engulfing candlestick pattern detection.

The Engulfing Bar indicator marks candlestick patterns where the body of the current bar fully engulfs the previous bar’s body. It helps spot potential reversal points after a short-term move.

Fractals

Fractals built-in indicator — download the project and explore Bill Williams fractal swing high and low markers.

Fractals mark local swing highs and lows using Bill Williams’ five-bar pattern. They help identify support/resistance pivots and structure in trending markets.

MACD

MACD built-in indicator — download the project and explore Moving Average Convergence Divergence trend and momentum signals.

MACD (Moving Average Convergence Divergence) shows the relationship between two moving averages. The histogram and signal line help assess trend direction, momentum, and potential crossovers.

Rate of Change

Rate of Change built-in indicator — download the project and explore momentum measurement as the speed of price change.

Rate of Change (ROC) measures the percentage change in price over a given period. It is a momentum oscillator used to compare current momentum with historical readings.

Indicators

Tutorial: Moving Average

Learn how to create and run a simple Moving Average indicator in FTO — perfect for getting started with custom indicators.

Ready to create your first custom indicator? Let’s start with a classic: the Moving Average.

In this tutorial, we’ll walk step by step through building, coding, and running this popular indicator in FTO.

Don’t worry — even if you’re new to indicators, this one’s a great warm-up. By the end, you’ll have a working Moving Average ready to test and tweak on your charts.

To see how things work in practice, start by downloading the archive with the indicator example.

Once it’s on your computer, open it in any IDE you like — but we highly recommend Cursor IDE for the smoothest experience.

For more details on how to open it in Cursor IDE, you can refer to this .

You can download the archive of Moving Average from here

3KB

moving-average.zip

archive

Open

How Custom Indicators Are Built

Every custom indicator in FTO starts with a simple but powerful idea: extend the IndicatorImplementation class from the forex-tester-custom-indicator-api library.

This class gives you all the building blocks you need — methods, structures, and tools — so you can focus on your logic instead of reinventing the wheel.

Every custom indicator can have its own set of adjustable parameters — things like periods, colors, or calculation methods.

These parameters are defined using the class, which handles different types (numbers, booleans, lists, etc.) and makes them easy to edit.

When you add or edit your indicator in FTO, these parameters will appear in a user-friendly window where you (or your users) can tweak the settings to get just the right behavior.

Think of it as the dashboard for your indicator — all the knobs and switches in one place.

For this, they need to be registered in the function.

Without registration, your parameters will just sit quietly in the code, never making it to the user interface.

Think of Init as the guest list at a party — if you don’t put your parameter on the list, it won’t get through the door.

You can see the methods for registering parameters in the

All the methods you’ll need to register your parameters live in the section of the API.

That’s the place where FTO tells you: “Here’s how to make your parameters visible in the UI and ready for users to tweak.”

So whenever you’re setting up parameters in the Init function, just look back at those definitions — they’re your cheat sheet for getting everything hooked up the right way.

Tip: Without registration, parameters stay hidden in the code. With registration, they become clickable, adjustable settings in the indicator window.

are the backstage crew of your indicator.

They’re used to store all those calculated values and then display them as lines, histograms, or other visuals right on your chart.

Think of them as the buckets where your indicator keeps its data before painting it onto the screen.

No buffers = no output. With buffers, your calculations finally become visible magic on the chart.

Buffers need to be both declared as class fields and initialized inside the function.

Creating buffers is just the start — now you need to tell FTO how many buffers will actually show up on the chart, and then bind each one by its index (starting from 0).

Each index must be unique, like seat numbers in a cinema.

In this example, we only need one buffer, so the setup looks like this:

IndicatorBuffers(1) → tells FTO, “I’ve got one buffer to draw.”
SetIndexBuffer(0, this.SSMA) → assigns our buffer SSMA to slot #0 on the chart.

Tip: If you ever add more buffers later (say, for multiple lines), just increase the number in IndicatorBuffers() and assign each one to its own index.

Each registered buffer isn’t just a data bucket — you can also how it’s displayed on the chart.

For example:

SetIndexLabel(0, "MA") → gives your buffer a friendly name (“MA”) so it shows up in the legend.
SetIndexStyle(...) → sets how it looks: here it’s a solid red line with thickness 1.
SetIndexDrawBegin(...) → defines the point on the chart where drawing should start (usually after enough data has been collected).