SMC Market Structure Signals + Dashboard + TP/SL📊 Full Performance Dashboard — provides a complete statistical overview, including the real-time ADR10 value, total signals, win rates for TP1/TP2, and a log of the last 10 trade outcomes.
✅ Advanced Quality Control Filters — user-configurable inputs for Max Pattern Bars, Max Pattern Height (% of ADR10), and Min Bars Between Signals eliminate low-quality or excessively large patterns and prevent over-signaling.
🔔 Comprehensive Alerts — get a single, detailed alert per signal—including the symbol, timeframe, entry price, SL, TP1, and TP2—formatted for easy integration with automated trading systems. Indikator
XAUMO TIMING DashboardXAUMO Timing Dashboard
Open-source UTC timing dashboard for traders who want better awareness of bar timing, session timing, overlap windows, holidays, and major USD event timing directly on the chart.
This indicator was built around a practical idea:
many traders watch price very closely, but they do not always watch time with the same discipline.
A setup can look good technically, but timing still matters:
- the bar may be seconds away from closing
- the 4H candle may be about to roll
- London may be close to ending
- New York may be opening
- a session overlap may be starting
- a major USD event may be near
This script helps bring that time awareness onto the chart in one compact dashboard.
WHAT THE INDICATOR DOES
XAUMO Timing Dashboard displays:
- current bar countdown
- higher-timeframe countdown
- official session countdown
- pre-market countdown
- after-market countdown
- major session countdowns
- overlap countdowns
- holiday awareness
- next major hard-coded USD event timer
- visual controls for text size, text color, background colors, and visibility toggles
Everything is displayed in UTC to keep the workflow consistent across symbols, brokers, and locations.
WHY IT CAN BE USEFUL
This tool is designed for traders who want to reduce timing mistakes.
It can help answer questions like:
- How much time is left before this candle closes?
- How close is the 4H close?
- Is London still active?
- Is the London / New York overlap running?
- Is a holiday affecting market participation?
- Is a major USD event getting close?
It does not predict market direction.
It improves timing awareness.
WHO IT MAY HELP
This indicator may be useful for:
- intraday traders
- scalpers
- session traders
- gold traders
- FX traders
- CFD traders
- traders who work with UTC-based timing models
- traders who want session and macro timing visible on-chart
HOW IT IS CODED
The script is written in Pine Script and uses an on-chart dashboard table.
The logic includes:
- countdown calculations from the current bar and a selected higher timeframe
- configurable UTC windows for official, pre-market, and after-market phases
- session state detection for major trading sessions
- overlap detection between major sessions
- hard-coded holiday packs
- hard-coded USD tier-1 event timestamps
- user controls for visibility and styling so the board can stay minimal or detailed depending on preference
The goal is practical chart awareness, not signal generation.
IMPORTANT NOTES
- This is a timing and awareness tool, not a buy/sell signal tool.
- It does not replace your own execution model, risk management, or market analysis.
- Session definitions can vary by broker and symbol, so official / pre-market / after-market windows are user-editable.
- Holiday and economic-event data in this version are hard-coded and should be reviewed and refreshed over time.
- Always confirm major event timing with your own trusted calendar before live trading.
OPEN-SOURCE AND COLLABORATION
This script is published open-source so traders and coders can inspect the logic, learn from it, and adapt it to their own workflow.
Constructive collaboration, improvement ideas, and responsible open-source contributions are very welcome.
If you build on this script or reuse any part of it in a publication, please respect TradingView House Rules and provide proper credit where required.
FINAL THOUGHT
Charts show price.
XAUMO Timing Dashboard helps show timing.
For traders who care about candle close, higher-timeframe rollovers, session transitions, overlaps, holidays, and macro-event awareness, this tool is designed to make time more visible on the chart. Indikator
Water Mark LAB
Description
The Water Mark LAB is a fully customizable, professional-grade chart watermark and minimalist HUD (Heads-Up Display) utility.
By releasing this script as Open-Source, traders and Pine Script developers can study how to effectively use the table drawing functions to create static, non-repainting text displays that remain fixed on the screen regardless of chart scrolling or zooming.
Key Features & Functionality
Instead of relying on the standard, inflexible built-in watermark, this tool creates a dynamic overlay that provides essential context at a glance without cluttering your price action.
Real-Time Data: Displays the current Symbol, Timeframe, Custom Text/Name, and the exact Current Price.
Volatility Tracker: Calculates and displays the "Daily Amplitude" (current daily high minus daily low) in both percentage and raw points/pips. This is crucial for day traders to know if the asset has already exhausted its average daily range.
Complete Customization: You have total control over the visual aesthetics. Choose from 9 different anchor positions on the screen (Top/Middle/Bottom + Left/Center/Right). Adjust text size, font weight (Bold), color, and transparency (from completely solid to barely visible) to suit any dark or light chart theme.
How to Use
Attach it to your chart, disable the default TradingView watermark in your chart settings, and position this HUD wherever it fits best. Use the Daily Amplitude feature to gauge intraday volatility momentum.
To comply with House Rules regarding non-English UI, here is the translation of the script's settings menu:
1. Informações Exibidas (Displayed Information)
Mostrar Símbolo = Show Symbol (Ticker)
Mostrar Tempo Gráfico = Show Timeframe
Mostrar Nome/Texto = Show Custom Name/Text
Texto Personalizado = Custom Text Input
Mostrar Preço Atual = Show Current Price
Mostrar Data e Hora = Show Date and Time
Mostrar Amplitude do Dia = Show Daily Amplitude (High - Low)
2. Estilo e Posição (Style & Position)
Tamanho do Texto = Text Size (Tiny to Huge)
Posição da Marca = Watermark Position (9 standard screen anchors)
Cor do Texto = Text Color
Transparência do Texto = Text Transparency (0 to 100)
Usar Negrito = Use Bold Font
Descrição
O Water Mark LAB é um utilitário Open-Source para customização avançada do seu gráfico. Mais do que uma simples marca d'água, ele funciona como um HUD minimalista construído através do sistema de tabelas do Pine Script.
Destaques
Contexto Rápido: Mostra o ativo, tempo gráfico, data/hora e preço atual em tempo real.
Amplitude Diária: Calcula automaticamente a variação do dia em pontos/pips e porcentagem, ajudando a identificar se o mercado já andou tudo o que tinha para andar no intraday.
Visual Flexível: Escolha entre 9 posições na tela, controle o nível de transparência e o tamanho da fonte para não poluir seus candles. Excelente base de estudo para uso de tabelas no código. Indikator
Global Risk DashboardWith the current global situation becoming increasingly unstable, markets across energy, precious metals, volatility, and crypto have been moving rapidly. During periods like this, it’s important to monitor multiple asset classes at the same time.
I noticed that I was constantly switching between several watchlists and charts just to keep track of the instruments I care about. To make this easier, I built a simple Global Risk Dashboard that displays all key markets in one place.
The dashboard allows you to quickly see price levels and daily performance across different asset groups, helping you understand the broader market environment without constantly changing charts.
Key Features
Custom Sections – Create up to 8 sections to organize markets however you like (Energy, Metals, Crypto, FX, Equities, etc.)
Up to 5 Instruments per Section – Monitor multiple assets within each category.
Enable / Disable Sections – Show only the groups you care about.
Enable / Disable Individual Instruments – Fully customizable layout.
Color-Coded Performance – Cells automatically change color based on daily performance.
Daily Price + % Change – Quickly identify which markets are moving.
Flexible Layout – Sections automatically adjust depending on what you enable.
Example Use Cases
You might organize sections like:
Volatility (VIX, VVIX, MOVE)
Energy (WTI, Brent, NatGas)
Precious Metals (Gold, Silver, Copper)
Crypto (BTC, ETH, Total Market Cap)
Macro (DXY, US Yields, Equity Indexes)
But the layout is fully customizable, so you can build a dashboard tailored to your own workflow.
Why This Tool Exists
The goal of this script is simple:
reduce the need to constantly switch between watchlists and charts during fast-moving market conditions.
Instead, you get a single, compact overview of the markets that matter to you. Indikator
Auto Play Ping/Pong [UAlgo]Auto Play Ping/Pong is a fully self running arcade style mini game built entirely in Pine Script and rendered directly on the chart. Instead of analyzing price, this script turns the chart area into a compact game field where two AI controlled paddles rally a moving ball from one side to the other while the score updates in real time.
The script is designed as a visual and technical showcase of what Pine Script can do with custom objects such as boxes, lines, labels, arrays, and user defined types. It demonstrates persistent state handling, frame by frame physics updates, collision detection, automatic paddle control, scoring logic, and motion trail rendering, all inside a chart overlay.
The left and right paddles are both controlled by simple AI logic. Each paddle reacts to the vertical position of the ball and tries to align itself for the next return. The ball bounces off the top and bottom boundaries, changes direction when it touches a paddle, and resets to the center when one side misses. A trail effect is also added to make movement easier to follow and visually more dynamic.
What makes this script interesting is that it is not simply drawing static shapes. It maintains a persistent game state across updates, modifies that state on every bar, and redraws the field using live object coordinates. This makes it a playful but technically instructive example of animation and object control in Pine Script.
In practical terms, this script is a creative visual project rather than a trading tool. It is useful for demonstrating real time state management, chart object animation, and game style logic inside TradingView.
🔹 Features
🔸 Fully Automated Gameplay
Both paddles are controlled automatically. The script continuously tracks the ball position and moves each paddle vertically to intercept the ball without user input.
🔸 Persistent Game State
The script uses a dedicated game state object to store ball position, paddle positions, scores, trail points, and drawing references. This allows the whole game to evolve smoothly over time.
🔸 Ball Physics and Collision Logic
The ball moves with its own horizontal and vertical velocity, bounces off the top and bottom walls, reacts to paddle contact, and changes its vertical angle depending on where it hits the paddle.
🔸 Score Tracking
If one paddle misses the ball, the opposing side scores a point. The ball then resets to the center and starts a fresh rally with directional variation.
🔸 Paddle AI With Speed Limits
Each paddle follows the ball using its own maximum movement speed. This gives the game a natural chase behavior and prevents instant teleport style motion.
🔸 Motion Trail Effect
The ball leaves a fading trail behind it using a sequence of stored points and prebuilt lines. This improves visual clarity and gives the movement a smoother arcade feel.
🔸 Custom Game Field Rendering
The play area is drawn with a background box, two paddle lines, a circular ball label, a score label, and trail segments. Everything is positioned relative to the current bar index.
🔸 Chart Overlay Animation
The game is drawn directly over the chart with overlay=true , which turns the chart into a moving visual canvas.
🔹 Calculations
1) Defining the Game Geometry and Core Constants
var int GAME_WIDTH = 80
var float GAME_HEIGHT = 100.0
var float PADDLE_H = 20.0
var float BALL_SPD_X = 1.8
var float BALL_SPD_Y = 1.2
var int TRAIL_LEN = 10
var float AI_SPEED_1 = 1.1
var float AI_SPEED_2 = 1.2
This block defines the full physical layout and motion parameters of the game.
GAME_WIDTH sets the horizontal size of the play area.
GAME_HEIGHT sets the vertical size.
PADDLE_H defines paddle height.
BALL_SPD_X and BALL_SPD_Y define the initial ball speed.
TRAIL_LEN defines how many trail segments are stored.
AI_SPEED_1 and AI_SPEED_2 define how quickly each paddle can move.
So before any gameplay starts, the script already establishes the dimensions and motion rules of the whole arena.
2) Defining the Point and Game State Objects
type Point
float x
float y
type GameState
float ball_x
float ball_y
float ball_vx
float ball_vy
float p1_y
float p2_y
int p1_score
int p2_score
box bg_box
line p1_line
line p2_line
label ball_lbl
label score_lbl
array trail_pts
array trail_lines
This is the structural foundation of the script.
The Point type stores one coordinate pair. It is used for the trail system.
The GameState type stores the full live state of the game:
the ball position,
the ball velocity,
the vertical positions of both paddles,
both scores,
the main drawing objects,
and the trail arrays.
This design is important because the script is not just drawing shapes independently. It is managing a complete game world through one persistent object.
3) Creating the Visual Objects on the First Bar
method init_drawings(GameState state) =>
state.bg_box := box.new(na, na, na, na, border_color=color.new(color.gray, 60), border_width=1, bgcolor=C_BG)
state.p1_line := line.new(na, na, na, na, color=C_P1, width=4)
state.p2_line := line.new(na, na, na, na, color=C_P2, width=4)
state.ball_lbl := label.new(na, na, "", color=C_BALL, style=label.style_circle, size=size.small)
state.score_lbl := label.new(na, na, "0 - 0", color=color.new(color.white, 100), textcolor=color.silver, style=label.style_none, size=size.large)
This method creates the core objects that will later be updated every frame.
The script builds:
a background box for the game field,
a line for the left paddle,
a line for the right paddle,
a circular label for the ball,
and a score label.
These are created only once, then reused and repositioned as the game evolves. This is much more efficient than deleting and recreating everything on every update.
4) Preparing the Ball Trail System
for i = 0 to TRAIL_LEN - 1
color fade_color = color.new(C_BALL, 100 - int((TRAIL_LEN - i) * 100 / TRAIL_LEN))
state.trail_lines.push(line.new(na, na, na, na, color=fade_color, width=2))
state.trail_pts.push(Point.new(state.ball_x, state.ball_y))
This loop initializes the trail effect.
For each trail slot, the script creates:
a line object with progressively changing transparency,
and a point initialized at the current ball position.
The idea is simple. The newest trail segments remain more visible, while older trail segments fade away. This creates the illusion of motion persistence behind the ball.
So the trail is not a single effect. It is a chain of stored points and lines that move along with the ball.
5) Updating Ball Position Each Frame
method update_physics(GameState state) =>
state.ball_x += state.ball_vx
state.ball_y += state.ball_vy
This is the first step of the physics engine.
On every update, the ball position is advanced by its horizontal and vertical velocity values. This is the basic motion rule of the game.
If nothing else happened, the ball would keep moving in a straight line forever. The rest of the physics method exists to modify that path through AI movement, wall bounces, paddle collisions, and scoring resets.
6) Left Paddle AI Logic
if state.ball_vx < 0
if state.p1_y + PADDLE_H/2 < state.ball_y
state.p1_y += math.min(AI_SPEED_1, state.ball_y - (state.p1_y + PADDLE_H/2))
else if state.p1_y - PADDLE_H/2 > state.ball_y
state.p1_y -= math.min(AI_SPEED_1, (state.p1_y - PADDLE_H/2) - state.ball_y)
This block controls the left paddle.
The paddle only reacts when the ball is moving toward the left side, which is why the script first checks:
state.ball_vx < 0
Then it compares the ball’s vertical position to the top and bottom edges of the paddle. If the ball is above the paddle center zone, the paddle moves upward. If the ball is below it, the paddle moves downward.
The amount of movement is limited by AI_SPEED_1 , which prevents the paddle from moving instantly.
So the left paddle behaves like a simple tracking AI that tries to align itself with incoming ball position.
7) Right Paddle AI Logic
if state.ball_vx > 0
if state.p2_y + PADDLE_H/2 < state.ball_y
state.p2_y += math.min(AI_SPEED_2, state.ball_y - (state.p2_y + PADDLE_H/2))
else if state.p2_y - PADDLE_H/2 > state.ball_y
state.p2_y -= math.min(AI_SPEED_2, (state.p2_y - PADDLE_H/2) - state.ball_y)
This is the mirror logic for the right paddle.
It only moves when the ball is traveling toward the right side. It uses the same tracking idea as the left paddle, but its maximum speed is set independently by AI_SPEED_2 .
That means each side can have slightly different behavior and difficulty characteristics.
8) Keeping Paddles Inside the Arena
state.p1_y := math.max(PADDLE_H/2, math.min(GAME_HEIGHT - PADDLE_H/2, state.p1_y))
state.p2_y := math.max(PADDLE_H/2, math.min(GAME_HEIGHT - PADDLE_H/2, state.p2_y))
After paddle movement is updated, the script clamps both paddles so they cannot leave the top or bottom of the field.
The center of each paddle must remain between:
PADDLE_H/2
and
GAME_HEIGHT - PADDLE_H/2
This ensures that the visible paddle body never extends outside the game frame.
9) Ball Bounce on Top and Bottom Walls
if state.ball_y >= GAME_HEIGHT
state.ball_y := GAME_HEIGHT
state.ball_vy := -state.ball_vy
else if state.ball_y <= 0
state.ball_y := 0
state.ball_vy := -state.ball_vy
This block handles vertical wall collisions.
If the ball reaches or exceeds the top boundary, its vertical position is snapped to the top edge and its vertical velocity is reversed.
If the ball reaches or drops below the bottom boundary, the same thing happens at the lower edge.
This creates a classic arcade bounce effect where the ball reflects off the horizontal walls and stays inside the arena.
10) Left Side Paddle Collision and Right Side Scoring
if state.ball_x <= 0
if math.abs(state.ball_y - state.p1_y) <= PADDLE_H/2 + 3
state.ball_x := 0
state.ball_vx := -state.ball_vx
state.ball_vy += (state.ball_y - state.p1_y) * 0.15
state.ball_vy := math.max(-4.0, math.min(4.0, state.ball_vy))
else
state.p2_score += 1
state.ball_x := GAME_WIDTH / 2
state.ball_y := GAME_HEIGHT / 2
state.ball_vx := BALL_SPD_X
state.ball_vy := BALL_SPD_Y * (state.p2_score % 2 == 0 ? 1 : -1)
This is one of the main gameplay blocks.
When the ball reaches the left boundary, the script checks whether the ball is close enough to the left paddle vertically. If yes, it counts as a successful return.
On a successful return:
the ball is snapped to the left edge,
its horizontal velocity is reversed,
and its vertical velocity is modified based on where it hit the paddle.
This extra adjustment is important because it creates angled returns rather than perfectly repetitive motion. The farther from the paddle center the hit occurs, the more the vertical speed is changed.
The vertical speed is then clamped between negative four and positive four to keep the game stable.
If the left paddle misses, the right side scores a point. The ball resets to the center, moves back toward the right, and gets a vertical direction that alternates based on score parity.
11) Right Side Paddle Collision and Left Side Scoring
else if state.ball_x >= GAME_WIDTH
if math.abs(state.ball_y - state.p2_y) <= PADDLE_H/2 + 3
state.ball_x := GAME_WIDTH
state.ball_vx := -state.ball_vx
state.ball_vy += (state.ball_y - state.p2_y) * 0.15
state.ball_vy := math.max(-4.0, math.min(4.0, state.ball_vy))
else
state.p1_score += 1
state.ball_x := GAME_WIDTH / 2
state.ball_y := GAME_HEIGHT / 2
state.ball_vx := -BALL_SPD_X
state.ball_vy := BALL_SPD_Y * (state.p1_score % 2 == 0 ? 1 : -1)
This is the mirror version of the left side logic.
When the ball reaches the right boundary, the script tests whether the right paddle is in position. If it is, the ball bounces back left and its vertical speed changes according to impact location. If not, the left player scores and the ball resets to center.
Together, the left and right boundary blocks define the full rally and scoring logic of the game.
12) Updating the Trail Memory
state.trail_pts.unshift(Point.new(state.ball_x, state.ball_y))
state.trail_pts.pop()
After the new ball position is resolved, the script stores it at the front of the trail point array. Then it removes the oldest stored point from the end.
This gives the script a rolling history of recent ball positions. Those points are later used to position each trail segment.
So the trail always follows the newest motion path while keeping a fixed length.
13) Converting Game Coordinates Into Chart Coordinates
method draw_frame(GameState state, int base_x) =>
int right_x = base_x + 5
int left_x = right_x - GAME_WIDTH
This method begins the rendering step.
The game is not drawn in a separate graphics window. It is projected directly onto chart coordinates. The current bar index acts as the base anchor, and the script defines a right edge slightly ahead of it. From that right edge, it subtracts the game width to get the left edge.
So the whole game field is mapped into a section of chart space that moves with the current bar position.
14) Drawing the Background and Paddles
state.bg_box.set_lefttop(left_x, GAME_HEIGHT)
state.bg_box.set_rightbottom(right_x, 0)
state.p1_line.set_xy1(left_x, state.p1_y + PADDLE_H/2)
state.p1_line.set_xy2(left_x, state.p1_y - PADDLE_H/2)
state.p2_line.set_xy1(right_x, state.p2_y + PADDLE_H/2)
state.p2_line.set_xy2(right_x, state.p2_y - PADDLE_H/2)
This block updates the main field and the paddle drawings.
The background box spans from the left edge to the right edge and from zero to the full game height.
The left paddle is drawn as a vertical line on the left boundary.
The right paddle is drawn as a vertical line on the right boundary.
Each paddle extends above and below its center position by half the paddle height. That makes the paddle length consistent and easy to manage mathematically.
15) Drawing the Ball and the Score
state.ball_lbl.set_xy(left_x + int(math.round(state.ball_x)), state.ball_y)
state.score_lbl.set_xy(left_x + GAME_WIDTH/2, GAME_HEIGHT - 10)
state.score_lbl.set_text(str.tostring(state.p1_score) + " - " + str.tostring(state.p2_score))
This block positions the moving ball and updates the scoreboard.
The ball label is placed by adding the ball’s internal game x coordinate to the left boundary of the field. Its y coordinate is the current ball height.
The score label is placed near the top center of the arena and updated with the current left and right scores.
So every frame, the game communicates both live motion and match progress.
16) Drawing the Motion Trail
for i = 0 to TRAIL_LEN - 1
Point p1 = state.trail_pts.get(i)
Point p2 = i + 1 < TRAIL_LEN ? state.trail_pts.get(i + 1) : p1
line l = state.trail_lines.get(i)
l.set_xy1(left_x + int(math.round(p1.x)), p1.y)
l.set_xy2(left_x + int(math.round(p2.x)), p2.y)
This loop converts stored trail points into visible trail segments.
For each trail slot, the script reads one point and the next point after it. Then it updates the corresponding trail line so it connects those two positions.
Because the trail lines were created with different transparency levels earlier, the newest segments appear stronger and older segments fade out.
This gives the ball a continuous motion streak that makes gameplay easier to follow visually.
17) Persistent State Initialization
varip GameState state = GameState.new(
ball_x = GAME_WIDTH / 2,
ball_y = GAME_HEIGHT / 2,
ball_vx = BALL_SPD_X,
ball_vy = BALL_SPD_Y,
p1_y = GAME_HEIGHT / 2,
p2_y = GAME_HEIGHT / 2,
p1_score = 0,
p2_score = 0,
trail_pts = array.new(),
trail_lines = array.new()
)
This block creates the persistent live game state.
The ball starts in the center of the arena.
Both paddles start in the vertical center.
Both scores start at zero.
Empty arrays are prepared for the trail points and trail lines.
The use of varip is important here because it keeps the game state persistent as the script updates, allowing the game to evolve continuously rather than resetting each time.
18) First Bar Initialization and Main Update Loop
if barstate.isfirst
state.init_drawings()
state.update_physics()
state.draw_frame(bar_index)
This is the main execution flow.
On the very first bar, the script creates all required drawings through init_drawings() .
After that, every update performs two steps:
first the game physics are advanced,
then the new state is rendered onto the chart.
This is the standard game loop pattern:
update state,
then draw state.
19) Invisible Plot Anchors
plot(100, color=color.new(color.white, 100))
plot(0, color=color.new(color.white, 100))
These invisible plots help stabilize the vertical scale for the game area.
Because the whole arena is designed between zero and one hundred on the y axis, plotting hidden values at those levels ensures the script keeps a consistent vertical drawing space.
This is a subtle but important implementation detail. Without it, the game objects could be compressed or mispositioned by automatic scaling behavior.
20) Practical Interpretation
Auto Play Ping/Pong is best understood as a Pine Script animation and state management demo rather than as a market analysis indicator. Its real value comes from showing how chart objects, arrays, persistent state, and update logic can be combined to create a living visual system inside TradingView.
The script demonstrates:
state persistence,
object reuse,
basic game physics,
simple AI motion,
collision handling,
score management,
and visual effects such as motion trails.
That makes it a strong example for anyone exploring creative Pine development, chart animation, or non traditional overlay design. Indikator
Indikator
Indikator
Indikator
AtolyeLAB - Icons & SymbolsThis indicator provides a large built-in icon library with 1000+ symbols and emojis that you can easily copy and paste into your own TradingView indicators, labels, tables, or scripts.
All icons are organized inside a single notepad panel in the settings, so you can quickly browse categories such as:
Arrows & directions
Trading & finance symbols
Shapes and geometric icons
Marks and indicators
Math & science symbols
Hearts and colors
Faces, gestures, animals
Tools, technology, documents
Trading labels (BUY, SELL, TP, SL, etc.)
And many more.
Simply open the Settings → Icon Notepad, copy the icon you like, and paste it wherever you want to use it in your Pine Script.
The indicator can also display a custom icon label directly on the chart, allowing you to test or preview icons easily.
This tool is designed to save time and make TradingView scripts more visual, expressive, and fun to build.
Enjoy using it and feel free to experiment with different icons in your indicators! Indikator
Ultimate Risk Manager: Fixed Dollar Risk & Position CalculatorAre you tired of manually calculating your position size to risk exactly $10, $50, or $100 per trade?
The Ultimate Risk Manager is a professional-grade position sizing and risk calculation tool designed for day traders and scalpers. Instead of guessing your position size and hoping your stop loss doesn't wipe out your account, this tool allows you to set a Fixed Dollar Risk. It tells you exactly how much margin to use so that if your Stop Loss is hit, you lose exactly the amount you planned for.
Perfect for futures and leverage traders on any exchange (MEXC, Binance, Bybit, etc.).
✨ Key Features:
🎯 Strict Risk Management: Input your desired risk (e.g., $2.00) and the calculator outputs the exact "Total Position" and "Margin" required based on your Stop Loss distance.
🤖 Auto Long/Short Detection: No need to toggle directions. The script automatically detects if it's a LONG or SHORT based on where you place your Stop Loss relative to your Entry.
💸 Built-in Fee Calculator: Input your exchange's round-trip fee percentage. The table calculates your exact fee cost and provides your Net Profit (after fees) at your Take Profit target.
🧹 Ultra-Minimalist Chart Visuals: Say goodbye to indicator lines cutting through your price action. This script uses short, clean floating markers for Entry, SL, and TP that sit neatly in the empty space on the right side of your chart.
🎨 Customizable UI: Includes a Light/Dark theme toggle, adjustable table positioning, and sliders to push the floating chart markers exactly where you want them.
🛠️ How to Use:
Open the indicator Settings (Double-click the table).
Under "Trade Setup," enter your Fixed Risk ($), Leverage, and Exchange Fee (%).
Under "Price Levels," use the Price Picker tool (the target icon) to click your desired Entry, Stop Loss, and Take Profit levels directly on the chart.
Look at the dashboard table! Copy the highlighted Yellow Margin Number and type it directly into your exchange's order box.
Protect your capital and trade like a professional by keeping your risk mathematically consistent on every single trade. Indikator
Indikator
Indikator
GlorifiedGamblers GFM Model (Pub Test v1)GlorifiedGamblers Alert System is a dual-model trade signal indicator built for ES/NQ futures on the 2-minute chart.
System 1 — Gann Flip Model: Captures the 8–9AM (ET) session high and low to build a dynamic Gann Box. After the session locks, the indicator monitors for breaks above or below the range. A "flip" is confirmed when price breaks out and then reclaims the level — signaling a potential reversal entry. Each flip is scored 0–10 using confluence factors including VIX, NQ confirmation, VWAP, RSI, volume, and clean vs. wick breaks.
System 2 — Liquidity Sweep + Inversion FVG: Tracks sweeps of key levels (PDH/PDL, Asia, London, NY AM session highs/lows, and the Gann Box). After a sweep, the model looks for an Inversion FVG to confirm a reversal or continuation setup.
All signals fire as JSON webhook alerts, making this compatible with automated alert pipelines. Indikator
Indikator
Indikator
Indikator
Indikator
Indikator
Indikator
Indikator
Indikator
Indikator
Worldwide EventsAn indicator that overlays key historical events directly on the price chart — from 1940 to the present day.
📅 Historical events — from World War II to modern crises and conflicts
📈 Plotted directly on the chart — see how the market reacted to each event
🎨 Color-coded categories — 🔴 High priority / 🟠 Medium priority / 🟡 Low priority
🔍 Date tooltip — hover over an event to see its date without cluttering the chart
⚙️ One-click filters — show only the categories you care about
🕰️ History going back to 1940 — Pearl Harbor, Black Monday, Lehman Brothers
💥 Financial crises — FTX, SVB, COVID crash, 2008 crisis
🌐 Geopolitics — wars, attacks, sanctions, oil embargoes
🏦 Monetary policy — every pivotal Fed and ECB decision on the timeline
🔄 Continuously updated — Liberation Day 2025, US-China tariffs, Iran
⚡ Zero configuration — works immediately after adding to the chart
🆓 Open source — full code available and modifiable
Event descriptions are available in the following languages:
🇬🇧 English (EN) (default)
🇵🇱 Polish (PL)
Source code is available here: github.com
Author: Piotr Kowalski "piecioshka"
Released: 2026-03-02 Indikator
