cloudparts

Legend

Goldman Sachs’s data modelling and governance platform, open-sourced through FINOS: describe business concepts once in the Pure language, map them to databases and services, and query or publish them as APIs while the engine generates the SQL.

FINOS · Incubating
What it is
Semantic layers
Type
Open source
Made by
FINOS (Linux Foundation), started at Goldman Sachs
Foundation
Fintech Open Source Foundation, incubating, joined January 2020. Incubating since its open-source release on October 19, 2020. Part of the Linux Foundation
License
Apache 2.0
Facts checked
28 October 2026
Website Source code

What it is

Legend puts a shared model between data and the people who use it. In Legend Studio, a web-based modelling environment with a visual editor and a text grammar, you define classes such as Trade or Person, with typed properties, multiplicities, associations and constraints that act as data-quality rules. Mappings connect each class to where the data really lives: tables in a relational store, other models, or service and document stores. Legend Engine, a Java server, takes a query written against the model, such as all trades filtered by desk and projected to a few columns, builds an execution plan and generates SQL for the database behind it. The engine ships extensions for about 20 relational databases, including Snowflake, BigQuery, Databricks, Redshift, Athena, Trino, Presto, PostgreSQL, ClickHouse, DuckDB, Spanner, Oracle, SQL Server and DB2. Lineage from source to query is computed from the mappings.

Around the model sit the other pieces. Legend SDLC stores models as entities in GitLab projects, so changes go through branches, reviews and versioned releases, and Legend Depot serves a read-only REST API over the published versions, which it loads from a Maven-style repository. Legend Query gives non-engineers a drag-and-drop query builder; any query can be promoted to a Legend Service, a REST endpoint backed by the same SDLC; and pylegend is a Python client. Models can also be translated to JSON Schema, Protobuf and Avro. Goldman Sachs built the platform internally as Alloy, with Pure as its language, and released five modules through FINOS in October 2020. FINOS runs a free shared instance for open, industry modelling work such as its Financial Objects special interest group, whose models are all public.

Why teams pick it

  • One model of business concepts, with constraints and lineage, mapped to many databases, so queries are written against names like Trade.desk and compiled to each store’s SQL
  • Models are managed like code: versioned in GitLab through Legend SDLC, reviewed, released as artifacts and served to other tools by Legend Depot
  • The same query can be run ad hoc in Legend Query, published as a REST service or called from Python, and models can generate JSON Schema, Protobuf and Avro
  • Used across Goldman Sachs’s divisions for years before its release, and Apache 2.0 licensed under FINOS

Watch out for

  • A heavy deployment: Studio, Engine, SDLC and Depot are separate services, and production needs GitLab with OAuth, SSL certificates and an identity provider; Docker Compose is meant only for a proof of concept
  • Pure is a language of its own, with its own grammar for models, mappings and queries, and few people outside the banks that use Legend know it
  • Still incubating at FINOS six years after its release, the stage for projects in their early growth phase
  • The FINOS shared instance is only for open models: every project in it maps to a public GitLab project, so proprietary models need your own installation

Alternatives

What all semantic layers have in common →Compare side by side →
CubeOpen sourceAn open-source, headless semantic layer: define metrics, joins and access rules once in YAML, query them over SQL, REST or GraphQL, and serve repeated queries from rollups it builds ahead of time.AtScaleCommercialA commercial semantic layer that presents warehouse tables to Excel, Power BI, Tableau and AI agents as cubes and metrics, translating their MDX, DAX and SQL into warehouse SQL and building aggregate tables to speed them up.MalloyOpen sourceA modelling and query language from Looker co-founder Lloyd Tabb that compiles to SQL: define joins and measures once in a source, then write short queries, including nested ones, that run on DuckDB, BigQuery, Snowflake, PostgreSQL and other engines.

How it fits with other technologies

A class, the table behind it, a mapping between them, and a REST service that queries the model · text

###Pure
Class model::Person
{
  name: String[1];
}

###Relational
Database store::PeopleDB
(
  Table People
  (
    id INTEGER PRIMARY KEY,
    name VARCHAR(200)
  )
)

###Mapping
Mapping mapping::PeopleMapping
(
  model::Person: Relational
  {
    name: [store::PeopleDB]People.name
  }
)

###Service
Service service::PeopleByPrefix
{
  pattern: '/people/{prefix}';
  documentation: 'People whose name starts with a prefix';
  autoActivateUpdates: true;
  execution: Single
  {
    query: prefix: String[1]|model::Person.all()
      ->filter(x: model::Person[1]|$x.name->startsWith($prefix))
      ->project([x: model::Person[1]|$x.name], ['Name']);
    mapping: mapping::PeopleMapping;
    runtime: runtime::PeopleRuntime;
  }
}

See it in a real stack

No architecture uses Legend yet. Drop it into the playground and wire it up yourself.Open playground →
Where it came from2020–2026

Goldman Sachs developed the platform for about seven years before releasing it, under the internal names Alloy for the platform and PURE for its language, as a way to keep data consistent across the many applications that use the same business concepts. Engineers and non-engineers across all of the bank’s divisions used it.

FINOS accepted the contribution in January 2020. From April to September 2020 a pilot ran a shared Legend instance on FINOS infrastructure, where Deutsche Bank, Morgan Stanley, RBC Capital Markets and others worked on extensions to ISDA’s Common Domain Model and on commodities reference data. On October 19, 2020 Goldman Sachs open-sourced five modules, Legend Studio, Legend Engine, Legend SDLC, Legend Shared and the Legend Pure language, under the new name Legend, chosen to present one platform for its data strategy.

The shared instance stayed open for industry modelling, and FINOS’s Financial Objects special interest group uses it for open financial data standards. Later additions included Legend Depot, Legend Query, a Python client and engine extensions for cloud warehouses. In October 2026 the FINOS landscape still listed Legend as incubating.

Why it’s built this way

Model first, storage second
Business concepts such as a trade are defined once and mapped to wherever the data lives, so consumers query names that mean the same thing in every application instead of each team’s tables.
Models in GitLab, not a metadata database
Treating models as versioned code gives them reviews, releases and dependencies, so a change to a shared definition is controlled like a change to a library.
A visual editor on top of a text language
Goldman wanted one platform for engineers and non-engineers: Studio lets analysts build models visually while the same model is stored as Pure text that engineers can diff and review.

Timeline

  1. 2020

    FINOS accepts the contribution in January; industry pilot on a shared instance from April to September

  2. 2020

    Goldman Sachs open-sources five modules as Legend on October 19; incubating at FINOS

  3. 2026

    Still incubating, with engine extensions for about 20 relational databases

Sources12 · facts checked 28 October 2026

Improve this page on GitHub