Domain-Specific Language (DSL)

A Financial Language for Thinking, Not Just Calculating

SEIOO is not just another charting platform with predefined indicators. At its core sits a Domain-Specific Language (DSL) designed specifically for financial reasoning. This language allows traders and investors to express how they think about markets in a structured, safe, and computationally efficient way. Instead of being limited to fixed indicators or black-box signals, users can define relationships, conditions, and composites across assets, timeframes, and indicators — and have them evaluated in real time at scale.

What makes this revolutionary is not only the language itself, but how it is designed to work hand-in-hand with Large Language Models (LLMs). The DSL is deterministic, safe, and verifiable. The LLM is creative, exploratory, and explanatory. Together, they form a system where humans describe intent, the LLM helps express it precisely in DSL form, and SEIOO executes it with institutional-grade rigor.

From Raw Market Data to Meaning

Every calculation in SEIOO begins with raw OHLCV data: open, high, low, close, and volume. This data arrives as historical candle series for assets such as BTC, ETH, equities, indices, or macro instruments. On its own, this data is noisy and difficult to reason about. The job of the Operations System is to transform that raw stream into structured, interpretable signals.

The transformation follows a strict and transparent pipeline. First, data is ingested and validated to ensure completeness and correct time alignment. Next, the system determines what to compute, whether that is a built-in indicator like RSI or MACD, or a fully custom expression written in the SEIOO DSL. Once the intent is known, the system computes the values using mathematically precise implementations. Finally, the result is returned as a time-aligned series that can be rendered in charts, tables, cards, or used as input to other widgets.

This flow is consistent whether you are computing a simple moving average or a multi-asset composite signal. The key difference is that the DSL allows users to move beyond single indicators and into structured financial logic.

Why a DSL Instead of “Just Indicators”

Traditional platforms treat indicators as isolated tools. You add RSI. You add MACD. You eyeball them and make a judgment. SEIOO treats indicators as building blocks. The DSL exists so that users can formally express ideas like:

• “I want a momentum signal that blends BTC RSI, ETH MACD, and SOL volume.”

• “I want to know when BTC and ETH are highly correlated over the last 30 bars.”

• “I want a condition that turns on when RSI is above 70 and volume is expanding.”

These ideas are not exotic. They are how experienced traders already think. What is new is the ability to express them directly, safely, and reproducibly.

For example:

composite(BTC.rsi, ETH.macd, SOL.volume)

This single line expresses a normalized, equal-weighted blend of momentum and participation across three assets. No spreadsheets. No manual normalization. No guesswork.

Or:

rollingCorrelation(BTC.close, ETH.close, 30)

This produces a rolling statistical relationship that can be tracked visually or used as a condition in higher-level logic.

A Real Language

The SEIOO DSL is not based on JavaScript eval() or any form of arbitrary code execution. That approach is both insecure and impossible to reason about at scale. Instead, SEIOO implements a full language pipeline: tokenization, parsing, and evaluation.

When a user writes a formula, the system first tokenizes the text into meaningful parts: asset references, operators, numbers, and function calls. These tokens are then parsed into an Abstract Syntax Tree (AST), a structured representation that makes the order of operations explicit and unambiguous. Finally, the evaluator walks this tree step by step, resolving values, applying functions, and producing deterministic results.

This design gives SEIOO several critical advantages. It guarantees security, because only allowed grammar can be executed. It guarantees correctness, because operator precedence and function behavior are explicitly defined. And it guarantees explainability, because every result can be traced back to its components.

What Users Can Express

The DSL supports direct access to asset-level indicators and prices, mathematical operations, logical conditions, and higher-level statistical functions.

A few examples illustrate the expressive power:

BTC.rsi

Fetches the current RSI value for Bitcoin.

BTC.close + ETH.close

Combines prices across assets.

BTC.rsi > 70

Produces a binary signal that can be used in logic or visualization.

weighted(0.5:BTC.rsi, 0.3:ETH.rsi, 0.2:SOL.rsi)

Defines an explicit weighting scheme across multiple inputs.

normalize(BTC.volume)

Scales raw volume into a comparable range so it can be meaningfully combined with other signals.

These expressions are not just visual tricks. They are first-class computational objects that can be charted, thresholded, combined again, or fed into other widgets.

Build Advanced Trading Engines with One Line

Multi-Factor Momentum Score with Trend Filter

(X:BTCUSD.rsi > 50 AND X:BTCUSD.adx > 25) * weighted(0.4: normalize(X:BTCUSD.rsi), 0.3: normalize(X:BTCUSD.macd), 0.3: normalize(X:BTCUSD.roc))

What it does:

• Only generates signals when RSI is above 50 (bullish) AND trend is strong (ADX > 25)

• Combines RSI, MACD, and Rate of Change with custom weights

• Result: 0 when conditions aren't met, 0-100 score when they are

Trading logic: High score = strong bullish momentum in a trending market

Mean Reversion with Volatility-Adjusted Bands

clip( 50 + (X:BTCUSD.close - sma(X:BTCUSD.close, 20)) / (std(X:BTCUSD.close, 20) * 2) * 25, 0, 100) 

What it does:

Calculates how far price is from its 20-period moving average Normalizes by volatility (standard deviation) Maps to 0-100 scale:

• 50 = at mean

• 0 = oversold

• 100 = overbought

Trading logic:

• Score < 20 → Buy signal (price extended below mean)

• Score > 80 → Sell signal (price extended above mean)

Cross-Asset Correlation Breakdown Detector

(rollingCorrelation(X:BTCUSD.close, X:ETHUSD.close, 30) < 0.5) * (lag(rollingCorrelation(X:BTCUSD.close, X:ETHUSD.close, 30), 5) > 0.8) *abs(X:BTCUSD.rsi - X:ETHUSD.rsi) 

What it does:

• Detects when BTC/ETH correlation breaks down (was >0.8, now <0.5)

• Multiplies by the RSI divergence between them

• Result: 0 when correlation is stable, high value when breakdown + divergence.

Trading logic:

Correlation breakdowns often signal regime changes - the asset with weaker RSI may be leading the move.

Composite Market Health Dashboard

composite(weighted(0.5: X:BTCUSD.rsi, 0.3: X:ETHUSD.rsi, 0.2: X:SOLUSD.rsi), normalize(X:BTCUSD.adx), 100 - normalize(X:BTCUSD.atr))

What it does:

• Combines momentum (weighted RSI across top 3 assets)

• Trend strength (ADX)

• Inverse volatility (low ATR = calmer market = higher score)

• Result: 0-100 "market health" score

Performance Without Compromise

Financial computation is expensive. Running RSI over thousands of candles, computing rolling correlations, or evaluating large composite formulas can easily freeze a browser if handled naively. SEIOO solves this by executing heavy operations inside Web Workers.

The user interface remains responsive while background threads handle the math. Results are streamed back only when ready. This architecture allows SEIOO to scale from simple dashboards to deeply nested, multi-widget analytical systems without degrading the user experience.

Crucially, the worker environment mirrors the main execution environment. The same operation registry, the same formula engine, and the same validation logic exist on both sides. This ensures that results are consistent, regardless of where they are computed.

Where the LLM Comes In

The DSL is intentionally precise and constrained. That makes it powerful, but also intimidating for new users. This is where the LLM becomes transformative.

Instead of replacing the DSL, the LLM acts as a translator and co-pilot. A user can describe an idea in natural language, such as:

“I want a signal that measures overall market momentum using RSI across the top three assets, but gives more weight to Bitcoin.”

The LLM translates that intent into a concrete, executable DSL expression. The DSL then executes it safely and deterministically. The user can inspect, modify, and reuse the result. Nothing is hidden. Nothing is guessed at runtime.

This separation of roles is critical. The LLM handles creativity and explanation. The DSL handles truth and execution. Together, they create a workflow where complex financial reasoning becomes accessible without sacrificing rigor.

Real Value for Traders and Investors

For traders, this means strategies can be expressed explicitly instead of implicitly. Signals can be tested, compared, and refined. Conditions can be made precise instead of vague. Composite views of the market can be built that reflect how professionals actually think.

For investors, this means clarity. Long-term signals, correlations, regime indicators, and confirmation logic can be visualized and monitored without relying on opaque scoring systems.

Most importantly, the SEIOO DSL turns analysis into infrastructure. Once expressed, an idea becomes reusable, composable, and inspectable. It can feed dashboards, alerts, summaries, and automation layers without being rewritten or reinterpreted.

A New Primitive for Market Analysis

The SEIOO DSL is not just a feature. It is a new primitive. It sits between raw data and human judgment, allowing intent to be formalized and executed at scale. By combining a safe, purpose-built language with LLM-assisted expression, SEIOO enables something that has not existed before: human-level financial reasoning, encoded and executed by machines, without losing transparency or control.

This is the foundation on which advanced signals, automation, and truly intelligent market systems are built.