Main Features
Core Scripting - TWM Core and Custom Indicators
Introduction
This lesson is available with subscription.
Ecosystem Access
Included with a TWM subscription
- Available as part of the TWM ecosystem
- Access remains active while your TWM subscription is active
- No separate purchase required for this course
This course is available inside the TWM platform.
Code Structure
This lesson is available with subscription.
Ecosystem Access
Included with a TWM subscription
- Available as part of the TWM ecosystem
- Access remains active while your TWM subscription is active
- No separate purchase required for this course
This course is available inside the TWM platform.
Execution
This lesson is available with subscription.
Ecosystem Access
Included with a TWM subscription
- Available as part of the TWM ecosystem
- Access remains active while your TWM subscription is active
- No separate purchase required for this course
This course is available inside the TWM platform.
Parameters
This lesson is available with subscription.
Ecosystem Access
Included with a TWM subscription
- Available as part of the TWM ecosystem
- Access remains active while your TWM subscription is active
- No separate purchase required for this course
This course is available inside the TWM platform.
Plots & Series
This lesson is available with subscription.
Ecosystem Access
Included with a TWM subscription
- Available as part of the TWM ecosystem
- Access remains active while your TWM subscription is active
- No separate purchase required for this course
This course is available inside the TWM platform.
Miscellaneous
This lesson is available with subscription.
Ecosystem Access
Included with a TWM subscription
- Available as part of the TWM ecosystem
- Access remains active while your TWM subscription is active
- No separate purchase required for this course
This course is available inside the TWM platform.
Free preview available
Create a free account to watch the preview lessons. No purchase required.
TWM
Courses
COURSES
Core Scripting
TWM Core and Building Custom Indicators: From Zero to Confident
Courses
This course is dedicated to the TWM Core and the complete foundation of custom indicator development. It is designed for users who want to move beyond basic usage and into real development within the TWM platform. You will learn not only how to build indicators, but how the underlying TWM API works, how execution flows through the system, and how all components interact in a real environment.
This course is intentionally positioned as the required step before moving into strategy development. Many of the concepts taught here apply to everything you will build in TWM — not just indicators. You will work with execution states, parameters, Series, plots, import/export workflow, debugging, and the internal lifecycle that every professional TWM tool relies on.
By the end of the course, you will have a reusable indicator template, a clear understanding of the TWM Core API, and the technical confidence to continue into advanced courses focused on automated strategies and full system development.
Description
This course provides a complete technical foundation for building custom indicators and understanding the TWM Core API. Although the examples are focused on indicator development, the knowledge gained here applies to all custom development within the TWM platform, including strategies, tools, and extensions.
🔹 1. Code Structure & Reusable Indicator Template
You will learn how to properly structure an indicator from top to bottom using a standard, reusable architecture:
- Private fields organization
- Indicator name and version handling
- Parameters, enums, and internal values
OnStateChangelifecycle and initialization logicOnBarUpdateexecution logic and core business flow- Custom rendering and visual logic
By the end of this module, you will have a universal indicator template that can be reused for most of your future TWM custom projects.
You will also learn what each section of the code is responsible for and why the order of structure matters for stability and performance.
🔹 2. GUID System & Import / Export Architecture
This section explains the internal referencing and portability system of TWM:
- What a GUID is and how it is used in TWM
- How to reference other indicators using reference GUID arrays
- How nested indicators are handled during import and export
- The full TWM import/export safety workflow:
- Compile before export
- Export operation
- Compile before import
- Automatic rollback on failed import
- How incorrect references break portability
- Rules for correct import/export:
- Class name must match file name
- Namespace must match folder structure
You will also test and validate this behavior in real scenarios to ensure your indicators remain fully portable across systems.
🔹 3. Execution Model & Runtime Behavior
You will gain a precise understanding of how indicators execute inside the TWM engine:
OnBarUpdateexecution logicOnStateChangestages with focus on:State.DefaultsState.Configured- How default values are defined and how user overrides work
- How input series are selected and processed
- How to attach Visual Studio to TWM for debugging
- How to use breakpoints and inspect runtime behavior
You will also learn:
- Why indicators should be created globally and not inside
OnBarUpdate - Why calling
EMA(100)[0]directly inside execution is inefficient - How and why global variables must be reset between initializations
🔹 4. Working with Input, Series & Embedded Indicators
This module teaches how to properly work with calculated values and indicator chaining:
- Understanding what
Inputrepresents - How to input one indicator into another via the UI
- How to create and manage custom
Series - How to calculate internal values such as:
(Low[0] + High[0]) / 2- How to pass calculated Series into built-in indicators
- How to use the output of embedded indicators for your own plots
This section forms the technical basis for combining multiple indicators into a single system.
🔹 5. Parameters & Auto-Generated Code
You will learn how the parameter system works internally:
- Defining indicator parameters
- Category grouping and display order
- How TWM auto-generates code during compilation
- How strategies initialize indicators using the generated code
- Understanding how parameters propagate from UI to runtime
You will also work with the custom DateTime type converter used in modern TWM strategies.
🔹 6. Plots, Panels & Visual Output
You will gain full control over indicator visualization:
- What
Seriesare and how they are displayed - Main price pane vs additional indicator panes
- Creating and naming plots
- Setting plot width, type, and style
- Data Box integration
- Assigning plot values inside business logic
- Changing plot colors dynamically during execution
- Using transparent plots to pass signals into strategies
- Using plot transparency to hide unwanted values and prevent visual noise
🔹 7. Drawing Objects & Visual Tools
You will work with built-in TWM drawing tools:
- Drawing lines using:
- Top
- Bottom
- Left
- Right anchors
- Creating and managing text objects
- Using loop-based calculations for drawing repetitive logic
🔹 8. Market Data Access & Indexing
This module focuses on how to correctly access chart data:
- Using:
CloseOpenHighLow- Time and Date indexes
- Understanding
CurrentBar - Where
CurrentBarmust be checked to prevent logic errors - How to safely reference historical bars
You will also learn how to prevent the most common runtime errors:
- Index out-of-range exceptions
- Reading beyond available bar history
- Improper lookback usage
🔹 9. Multi-Panel Indicators & Visual Layer Control
You will learn how to:
- Use more than one additional panel
- Plot lines on:
- Price pane
- Indicator pane
- Multiple additional panes dynamically
- Switch plotting behavior at runtime
🔹 10. Chart & Bar Coloring
This section covers full visual styling control:
- Coloring the chart background:
- On the current bar
- On previous bars
- Coloring price bars dynamically based on logic
- Using colors for conditions, states, and execution feedback
✅ Outcome of This Course
After completing Core Scripting, you will:
- Fully understand the TWM Core execution model
- Have a professional reusable indicator template
- Know how to:
- Build
- Debug
- Export
- Import
- Embed
- Visualize
- Chain indicators
- Be fully prepared to move into:
- Strategy development
- Automation
- Advanced TWM system design
Complete TWM Core API Foundation
Learn how the TWM engine works internally, including execution flow, states, initialization, and runtime behavior used across all custom development.
Professional Reusable Indicator Template
Build a full production-ready indicator structure that you can reuse for most future custom projects.
Execution Model & Debugging Workflow
Master OnBarUpdate, OnStateChange, Visual Studio debugging, breakpoints, and runtime inspection inside TWM.
Series, Input & Indicator Chaining
Learn how to calculate custom Series, pass them into built-in indicators, and chain multiple indicators together efficiently.
Parameter System & Auto-Generated Code
Understand how parameters work, how category ordering is handled, and how TWM generates initialization code for strategies.
Plots, Panels & Visual Output Control
Full control over plots, multiple panes, dynamic colors, transparency, and Data Box integration.
Reliable Import / Export & GUID Architecture
Learn how to correctly export and import indicators with all dependencies using TWM’s GUID and reference system.
Advanced Chart & Bar Visualization Tools
Work with draw objects, text labels, background coloring, and dynamic bar coloring based on real-time logic.
FAQ
Do you have any more questions about our Course? Let's see if we already have the answer.
Please read the FAQ below.
Is this course only about indicators?
No. While the course uses indicators as the main learning format, it focuses on the TWM Core API. Many of the concepts taught here apply to strategies, tools, and all custom development in TWM.
Do I need programming experience to take this course?
Basic knowledge of C# is recommended. You do not need advanced experience, but you should already understand core programming concepts like variables, methods, and loops. Please take 101 course if you have not.
Should I take this course before the strategy course?
Yes. Core Scripting course is the required foundation before moving into strategy development. It explains how the platform executes, initializes, and manages custom logic.
Will I be able to build my own indicators after completing the course?
Yes. By the end of the course, you will have a reusable indicator template and the knowledge required to build, debug, and deploy your own custom indicators.
Does this course cover debugging and error handling?
Yes. You will learn how to attach Visual Studio to TWM, use breakpoints, inspect runtime values, and prevent common execution errors.
Will I learn how to combine multiple indicators together?
Yes. The course explains how to create custom Series, embed indicators inside other indicators, and use their output in your own calculations and plots.
Does the course explain how indicator parameters work?
Yes. You will learn how parameters are defined, grouped, passed from the UI to runtime, and how TWM auto-generates code for indicator initialization.
Is import and export of indicators covered?
Yes. The course explains the full import/export workflow, including GUID references, dependency handling, compilation checks, and rollback behavior.
Can I use what I learn here for strategy development later?
Absolutely. The Core API knowledge from this course is directly applied in strategy development and automation.
Is this course suitable for users who want professional-grade control over TWM?
Yes. This course is specifically designed for users who want full technical control over their indicators and a deep understanding of how the TWM platform operates internally.
Still have a question?
For assistance, please visit our Support page. Our dedicated team is ready
to help you 24/7.
Testimonials
Check out here what the other users have to say about this Course!
Michael T. — Day Trader
"“Debugging inside TWM used to be a nightmare for me. After the Visual Studio attach and execution flow lessons, everything clicked. Huge confidence boost.”"
Victor L. — Quant-Oriented Trader
"“This was the missing link between basic coding and real system development in TWM. After this course, moving into strategy automation felt natural, not overwhelming.”"
Daniel M. — Futures Trader & Developer
"“This course finally explained how TWM actually works under the hood. After 102, I stopped guessing and started building indicators with a proper structure. The Core execution part alone is worth it.”"
Robert S. — Software Engineer
"“What I liked most is that this is not just an indicator tutorial. It’s a full Core API breakdown. The reusable template I built during the course is now my base for every project.”"
Chris P. — Independent Strategy Developer
"“The import/export and GUID section saved me from breaking my projects multiple times. I finally understand how to properly package indicators with all dependencies.”"
Alex K. — Algorithmic Trading Enthusiast
"“I had been using indicators for years, but never really understood the lifecycle and states. This course made everything clear — especially how to chain indicators correctly using Series.”"
Similar courses
TWM users have the opportunity to create their own strategies and indicators using the C# coding language.