TradeBricksDocsOpen the Lab →
The Market

The Marketplace

Strategies in TradeBricks are portable JSON specs — pure data, no code. That makes them safe to publish, browse, and fork. The Market is where the community shares them.

Strategies are portable specs

When you publish a strategy, what travels is the same spec the Lab compiles your graph into: a list of nodes (each a brick id plus its params), a list of edges (which port wires to which), and a little metadata. That’s it.

a published strategy is just this shape
{
  "meta":  { "name": "RSI reversion", "version": 1 },
  "nodes": [
    { "id": "es",  "brick": "data_source", "params": { "source": "ES 5m" } },
    { "id": "rsi", "brick": "rsi",         "params": { "length": 14 } },
    ...
  ],
  "edges": [
    { "source": "es", "sourcePort": "close", "target": "rsi", "targetPort": "x" },
    ...
  ]
}
Non-injectable by design

A spec contains no code — only brick ids and numbers. Loading someone’s strategy can never execute anything on your machine; the engine just looks up known bricks and wires them.

This is true of every brick, not just one. The whole catalog is a closed whitelist of pure evaluators with no eval or exec anywhere, so the most a shared strategy can ever do is compute indicators from that catalog. Even the formula brick — the one place you type free-form math — stays inside it: its expr is parsed to an AST and run by a restricted evaluator (numbers, named inputs, a fixed set of operators and functions only), never a real interpreter. See every brick is a whitelisted evaluator. That whole-catalog guarantee is what makes a public marketplace of arbitrary strategies safe to use.

Publishing

Built something you’re proud of? Publish it so others can learn from and build on it.

  1. Open the strategy in the Lab and give it a clear name and description.
  2. Publish. Your graph is serialized to the spec above and listed on the Market under your name.
  3. It appears as a card showing the bricks it uses, plus its fork and like counts.
Publish honestly

A great-looking equity curve on Dev isn’t an edge. If you share a strategy, share what its holdout and overfitting guards actually said. The community is better served by an honest “interesting but unproven” than by an overfit curve dressed up as a winner. See Backtesting.

Browsing

The Market shows published strategies as a grid of cards. Each card surfaces:

  • The strategy name and its author.
  • A short description of the idea.
  • The bricks it uses, as tags — a quick read on its category and complexity.
  • Counts for bricks (▦), forks (⑂), and likes (♥).

Forking

Forking is the heart of the Market. Found a strategy you want to understand or improve? Fork it into your own Lab and it becomes a fully editable copy — same graph, now yours to tweak, re-backtest, and re-publish.

Why forking works so well here

  • It’s a real copy, not a black box. Because the spec is open data, a fork lands as actual bricks on your canvas — you can see and change everything.
  • It’s safe. No code comes with it, so forking can’t run anything unexpected.
  • It teaches. Reverse-engineering a good strategy brick by brick is one of the fastest ways to learn the Lab.
  • It compounds. Forks track their origin, so good ideas get iterated on in the open.
Fork to verify, not just to copy

When you fork a strategy, the honest move is to re-run it yourself — especially on the holdout. A strategy that only ever looked good on its author’s Dev slice will tell you the truth the moment you backtest your fork.

Forks that use live data

A forked strategy may use live or alt-data bricks. Because strategies declare a capability (like options) rather than a specific broker, a fork runs unchanged for anyone with a matching connected provider — and the built-in Congress/SEC bricks work for everyone.

Related reading