Rune DSL Studio

A complete workbench for Rune DSL — model, build, and validate FINOS CDM, DRR, FpML, or any Rune DSL domain model, end to end inside your editor.

Rune DSL Studio takes a .rosetta model from first type declaration to running, validated output: author and explore models with full language support, build them with one click — no Maven setup, no toolchain wrangling — author, generate, and execute real Java natively in the editor, and validate against the model's own rules. Working with a reporting model like DRR? Studio carries you the rest of the way, from enriched events to regulatory wire formats. Modelling something else entirely? Rune DSL is domain-agnostic, and so is Studio.

Any mention of "Rosetta" herein relates to the .rosetta file extension and the open-source Rune DSL language, not any licensed platform.

Project / Build Manager

Building a Rune DSL model normally means hand-managing a complex Maven build — wiring poms, classpaths, and toolchain jars before you can compile a line. Studio removes all of it: create a project from a model source (FINOS CDM, DRR, or your own) and Studio wraps it in a managed project with full build management. DRR is a private model, so building it requires a GitHub account with rosetta-models authorisation. The Master Build downloads the model, compiles the Rosetta DSL to its Java implementation, extracts the toolchain, and indexes everything for navigation and search — a nine-step pipeline with a live build log, named steps, and javac diagnostics surfaced straight into the Problems panel.

• Environment checklist — Java, Maven, Python, GitHub sign-in and model access verified up front, with one-click fixes and expandable detail drawers for anything that fails. On a locked-down corporate network, Run Corporate Compatibility Checker goes further: it probes every backend endpoint over both the editor's and the build's network paths, checks the toolchain, disk, TLS and proxy handling, and writes a local diagnosis — it changes nothing and uploads nothing.
• Incremental rebuilds — edit, override, and rebuild; only what changed is recompiled.
• Vendor overrides done properly — unlock a read-only vendored file and Studio creates an override namespace copy in your own tree; the vendor base is never touched, the Modifications panel tracks every change with live status pills, and deleting an override heals back to base.

Coding Suite

Full .rosetta language support across the whole model — not just your open file:

• Syntax highlighting, autocomplete, and hover documentation for types, enums, functions, and annotations.
• Namespace tree — the entire model organised by namespace, with per-file categories and instant navigation.
• Workspace-wide search and symbol indices covering thousands of model files, powering go-to, outline, and reference lookups.
• Live validation — problems surface as you type, with a warm background toolchain keeping generation and validation responsive in seconds, not JVM cold starts.
• Native Java, first-class — generate a model's Java implementation and navigate it as real source, and author your own custom Java against the model; Studio compiles both with the model's own toolchain — no separate Java project to wire up.

Rune DSL Copilot — Multi-Model AI Integration

Deep integration with your AI coding assistant — GitHub Copilot and Claude Code among the options under evaluation — is in development: page and context awareness inside Studio's surfaces, guided setup assistance, and model-aware coding assistance that understands Rune DSL semantics, not just syntax.

Model Visualisation

A Three.js-powered type relationship explorer: anchor on the model's root type and watch the structure expand outward — types, attributes, enums, inheritance, and cross-namespace references, navigable in three dimensions. The same graph anchors inside RuneBooks, so you can see a type's shape the moment you author it.

RuneBook — an interactive model notebook

RuneBooks are interactive notebooks for prototyping and learning Rune DSL and its Java integration points — author a type, generate its Java, run it, and validate it in one living document you work in directly. Your own custom Java and the toolchain's generated Java sit side by side, clearly distinguished:

• Rune layer — author .rosetta source with syntax highlighting, autocomplete, and per-file helper documentation.
• Java layer — one click generates real Java through the official toolchain; the generated classes open as read-only reference right beside your own editable custom Java, so the boundary between what the model produces and what you write is always clear.
• Run it — execute functions with parameter input, run full custom pipelines against wired sample data, build object instances interactively, and store them as reusable named inputs.
• Validate — run the type validator, cardinality checks, and condition rules with a detailed results view.
• Templates — start from pre-built templates with guided steps in the sidebar.

Designer

A guided accelerator for CDM onboarding. Pick a starting point, answer what the model asks, and the Designer assembles a valid object as you go — qualifying it live against your model's own qualification functions, then building the matching code, executing it, validating it, and exporting it into your project. It moves in five steps:

• Setup — make the structural choices the model requires. The Designer surfaces the qualification route and each choice it opens up, and qualification runs only when you explicitly ask — nothing fires on a stray click. Honest by design: a product the model itself cannot qualify is flagged with the reason, never silently absent.
• Qualify — the resolved result, read semantically. The choices that change what the trade is — option direction, cash vs physical settlement, the booking basis, exercise style — are shown with their real model values, and anything the chosen route rules out folds under a plain not applicable line with the reason and a way back.
• Model — the qualified product as an interactive model view: structure, the choices you made, and the projected JSON side by side, exportable as crisp PNG or Mermaid.
• Execute — run the built object through the model's own validation rules, inspect the result, and store instances as named objects in the project's object store.
• Export — real, usable builder / factory-pattern Java — a clean skeleton to complete, or seeded with sample data so a realistic instance appears straight away — plus a runner and per-product run scripts (Windows and macOS), each product in its own package. Add to Project drops the result into your build.

Beyond the base trade, the Designer also builds post-trade lifecycle events against a trade you have built: it detects which events apply, then qualifies and walks the one you choose through the same five steps. What you execute is stored as a named instance, and a top-down lineage view lays out the resulting chain of states and the events between them, with before-and-after quantities at each step.

The Designer is derived from the model you are working on, not hardcoded: it works across CDM major versions 5, 6 and 7 — and DRR projects through the CDM embedded in them — with the qualification flow, choices, semantic values, and generated code all read from that version's own model. Each supported major is exercised against its complete built-in sample product set before release.

The effect is to compress the analysis-and-build phase of onboarding: the Designer takes on roughly 95% of the initial effort of standing up a CDM product — turning what is typically months of work into days. It won't populate every optional field — the last mile stays yours.

It is early and evolving, so treat it as a preview: explore it, and tell us where it helps or gets in the way.

Current scope: the base trade (ContractFormation) plus post-trade lifecycle events built against it, with an instance store and a top-down lineage view over the resulting states and events. Coming next: DRR regime selection — creating the ReportableEvent and report runners/builders for any CDM product/event combination, with rich documentation to support your design.

DRR Data Lineage

Ask any field of a DRR report where its value comes from — and read the answer on one page, straight from the compiled model. Open the Regulatory tab in a built DRR 7.x project and choose DRR Data Lineage. Pick a report (twelve reports across nine regimes: ASIC, CFTC, CSA, ESMA EMIR, FCA UK EMIR, HKMA, JFSA, MAS and SEC), pick a field — or search the full list — and the field's journey renders in four layers:

• Declaration — the regulation's own definition of the field, tier by tier, provisions and citations verbatim;
• Extraction — the model rule that computes the value, with the real code lit along its route;
• Projection & Submission — where the value lands in the ISO message for each action type (new, modification, correction, …), down to the document path and the wire legs;
• Validation — the checks that guard the field.

What you read is what runs — every line comes from the same compiled model your build uses; nothing is hand-written. The lineage pack downloads once per DRR release on first open (~95 MB) and is cached locally. Packs are published per DRR release, starting with 7.4.0 — on other versions the page tells you which packs exist. Available in built DRR 7.x projects; access follows your DRR model access. DRR Data Lineage ships as a beta — feedback is welcome through the in-product feedback button.

Training

The first course — CDM & DRR end to end — is available in Studio now, with more to follow. A full four-module, hands-on walkthrough from first enum to regulator-ready XML:

Every lesson runs against the real toolchain — real builds, real validation, deliberate-break exercises, and a guided sidebar that tracks your progress.

Execution Harness

Run whole-model regression pipelines at scale: ingest event batches, validate ReportableEvents, generate and validate transaction reports per regime, and project to XML — with live dashboards for throughput and findings, per-stage validation rollups, and top-exception triage that takes you straight to what broke.

Getting started

1. Install the extension and open the Rune DSL Studio sidebar.
2. The welcome view checks your environment — Java 21, Maven, Python 3.10+, GitHub sign-in — with one-click fixes for anything missing.
3. Create a project from a model source and run the Master Build (first build downloads and compiles the full model — allow a few minutes).
4. Open a .rosetta file, a .runebook, the graph view — or start the training course from the Training panel.

Requirements

Feedback & support

All feedback flows through the app itself — the feedback icon in the Studio sidebar or the Rune DSL: Send Feedback… command. Choose Bug, Suggestion, or Technical Issue; diagnostics attach automatically so we can act on it, and your GitHub login rides along so we can follow up.

Releases and release notes: github.com/nubbymong/rune_dsl_studio

Privacy & data

Rune DSL Studio runs entirely on your machine and collects no background telemetry. The only outbound data is user-initiated: when you submit feedback, the report — with the diagnostics you can review first, plus any optional screenshot and email you attach — is sent over HTTPS via a maintainer-operated relay (a Cloudflare Worker) and raised as an issue in a private repository visible only to the maintainer; it is never published publicly. Those diagnostics are limited to your plugin / VS Code / OS versions, environment-check results, and an anonymised (hashed) workspace identifier so related reports can be correlated — never file contents or model data. GitHub authentication uses VS Code's native OAuth; any local secrets the extension stores are held in the editor's SecretStorage. The bundled MCP server exposes read-only model-grounding tools to a locally-configured AI client and makes no autonomous network calls.

Attribution & licensing

License: Rune DSL Studio is proprietary software — all rights reserved; see the LICENSE file. The bundled third-party toolchain is licensed separately under its own terms, as set out below.

So that projects build without external toolchain setup, this extension bundles the Rune DSL build toolchain — an open-source project hosted by FINOS (the Fintech Open Source Foundation), maintained by Regnosys. The ~120 third-party dependency components (Jackson, Guava, Apache Commons, SnakeYAML, …, and the Eclipse EMF/Xtext/LSP4J/JDT stack) are redistributed unmodified under their own licenses — principally Apache 2.0 and the Eclipse Public License (EPL), with a small number of MIT, BSD, and CDDL components. The Rune DSL engine itself is incorporated under the Apache 2.0 license and is recompiled/modified by the maintainer; modified files are acknowledged in THIRD-PARTY-NOTICES per §4 of that license. Every bundled component and its license is enumerated in the THIRD-PARTY-NOTICES file that ships with the extension; a CycloneDX SBOM and an OSV CVE scan — with accepted-risk notes for the build-time-only advisories — are published in the source repository.

Related projects: FINOS · Rune DSL · FINOS Common Domain Model (CDM) · Digital Regulatory Reporting (DRR).

Disclaimer

This extension is provided "as-is" without warranty of any kind. Evaluate suitability before use in production environments.

Rune DSL Studio is an independent, community-built extension. It is not affiliated with, endorsed by, or sponsored by FINOS, ISDA, Regnosys, or any other organisation.

"Rosetta". Rosetta is a commercial SaaS modelling platform and a trademark of Regnosys. This extension is not affiliated with, endorsed by, or connected to Regnosys or the Rosetta platform. References to "Rosetta" here — the .rosetta file extension, historical package/classpath names, and language tooling — refer solely to the open-source FINOS Rune DSL language (formerly named Rosetta DSL — hence package names such as com.regnosys.rosetta.*) and its file format, not the Regnosys product.

_{Rune DSL Studio © Nicholas Moger · Built with the open-source Rune DSL toolchain (FINOS)}