01 — Research Workspace

A structured workspace for systematic strategy research

A code-first environment where strategy logic, parameters, and validation workflows operate inside the same research system.

Define strategy logic in QSL
Control parameters and optimization ranges explicitly
Run Baseline → Optimization → WFA → Adaptive Flow without leaving the workspace
Start ResearchView Workspace Overview →
strategy.qsl×
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/**
* Define strategy parameters
* Called once when strategy is loaded
*/
function define(ctx) {
  ctx.param('fastLength', {
    type: 'int',
    label: 'Fast EMA Length',
    default: 9,
    min: 5,
    max: 50,
    step: 5,
    optimize: true,
  });
  ctx.param('slowLength', {
    type: 'int',
    label: 'Slow EMA Length',
    default: 21,
    min: 10,
    max: 200,
    step: 10,
    optimize: true,
  });
}
// Entry logic
if (emaCrossUp(ctx)) {
  ctx.enterLong()
}
Console
Baseline Validation:PASS
Robustness Score:0.61
Assets Tested:12
StrategyOptimizationValidationDeploymentAdaptive Flow

Part of the Quanthop strategy research pipeline

A research IDE for systematic trading

Quanthop provides a structured workspace for developing and validating systematic trading strategies. Strategy logic, parameter definitions, and validation workflows operate inside the same research environment.

Strategy Editor

Write strategy logic in QSL with explicit parameter definitions.

Parameter System

Define parameter ranges, defaults, and optimization behavior directly inside the strategy.

Validation Engine

Run Baseline, Optimization, Walk-Forward, and Adaptive Flow from the same workspace.

QSL Strategy Language

Code-first strategy development with QSL

Strategies in Quanthop are written using QSL, a structured language designed for reproducible strategy research.

QSL is intentionally constrained to ensure strategies behave deterministically during validation.

Key characteristics

Explicit parameter definitions
Deterministic strategy execution
Built-in indicator functions
Direct integration with the validation pipeline
strategy.qsl×
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/**
* Define strategy parameters
* Called once when strategy is loaded
*/
function define(ctx) {
  ctx.param('fastLength', {
    type: 'int',
    label: 'Fast EMA Length',
    default: 9,
    min: 5,
    max: 50,
    step: 5,
    optimize: true,
  });
  ctx.param('slowLength', {
    type: 'int',
    label: 'Slow EMA Length',
    default: 21,
    min: 10,
    max: 200,
    step: 10,
    optimize: true,
  });
}
// Entry logic
if (emaCrossUp(ctx)) {
  ctx.enterLong()
}

Parameters defined in the strategy automatically appear in optimization and walk-forward validation stages.

Backtest·BTCUSDT · 1D · ema_cross v0.3
Done
[14:32:01]ⓘ[engine]Starting backtest run #48
[14:32:01]ⓘ[engine]Run hash: a7f2c91
[14:32:04]✓[engine]Execution complete — 142 trades
[14:32:04]ⓘ[engine]Previous hash: a7f2c91
[14:32:04]✓[verify]Deterministic — identical to run #47
[14:32:04]✓[result]Net return: +34.7%

Execution Model

Deterministic execution model

Strategy behaviour must be predictable.

Quanthop executes strategies inside a deterministic simulation engine where identical inputs always produce identical outputs.

This ensures

Reproducible optimization results
Reliable walk-forward validation
Consistent research comparisons across strategy versions

Running the same strategy with the same parameters and data will always produce the same result.

Parameter Control

Parameters are part of the research model

Parameters in Quanthop are defined explicitly as part of the strategy.

Each parameter definition includes:

Minimum and maximum bounds
Default value
Step resolution
Optimization flag

These constraints ensure optimization explores meaningful regions of parameter space rather than arbitrary values.

strategy.qsl×
1
2
3
4
5
6
7
8
9
ctx.param('slowLength', {
  type: 'int',
  label: 'Slow EMA Length',
  default: 21,
  min: 10,    // lower bound
  max: 200,   // upper bound
  step: 10,   // grid resolution
  optimize: true,
});

The min, max, and step values define the optimization search space.

Explorer
Historyv4
v1

Initial strategy

17d ago
3 experiments
v2

Adjusted EMA bounds

14d ago
5 experiments
v3

Added RSI filter

12d ago
8 experiments
v4Current

Parameter refinement

10d ago
12 experiments

Research Tracking

Every strategy iteration is versioned

Strategy development is iterative. Each modification to a strategy creates a new research version within the workspace.

Research versions allow you to:

Compare strategy iterations
Reproduce previous experiments
Maintain a complete research audit trail

This creates a structured record of strategy evolution over time.

Validation Pipeline

Validation runs directly inside the workspace

Once a strategy is defined, it flows directly into the Quanthop validation pipeline. Every stage of research runs inside the same workspace.

baseline_report

Baseline Validation

Evaluate strategy behaviour across multiple assets.

PASS
optimization.log

Parameter Optimization

Explore parameter combinations within defined bounds.

Stable
wfa_results

Walk-Forward Analysis

Test strategy stability across rolling in-sample and out-of-sample windows.

Stability: 0.63
adaptive.log

Adaptive Flow

Monitor strategy behavior and trigger re-optimization when required.

Active

Start building structured strategies

Quanthop provides a research environment designed for disciplined strategy development. Secure access to begin building and validating strategies.

Start Research
Research PipelineNext: Structured Validation