Ecosystem

The Virtufin platform is a federation of focused repos. Each repo ships its own documentation site; the sites cross-link so a developer can find related material without leaving the platform.

Solid arrows are real dependencies (package/build-time); dashed arrows are "deploys" relationships, not code dependencies. Click any node to open its docs site (or repo page, where no docs site exists).

graph TD
    subgraph Foundation
        dotnet["virtufin-dotnet<br/>.NET core libraries"]
        openspec["virtufin-openspec<br/>domain spec"]
        common["virtufin-common<br/>CI/build tooling for all repos"]
    end

    subgraph "Core services"
        api["virtufin-api<br/>API gateway"]
        service["virtufin-service<br/>multi-instance coordination"]
        wm["virtufin-workmanager"]
        wsm["virtufin-websocketmanager"]
    end

    subgraph "Dev kits"
        stratdevkit["virtufin-strategy-devkit"]
        execdevkit["virtufin-execution-devkit"]
        indicdevkit["virtufin-indicator-devkit"]
        mddevkit["virtufin-market-data-devkit"]
    end

    subgraph "Deployable workers"
        strategies["virtufin-strategies"]
        execengines["virtufin-execution-engines"]
        indengines["virtufin-indicator-engines"]
        mdengines["virtufin-market-data-engines"]
        workers["virtufin-workers"]
        examples["virtufin-examples"]
    end

    subgraph Frontends
        tui["virtufin-tui"]
        app["virtufin-app"]
        site["site"]
    end

    subgraph Deployment
        helm["helm"]
        deploylocal["deploy-local"]
        dockercompose["docker-compose"]
    end

    docs["docs<br/>(this site)"]

    service --> api
    wm --> api
    wm --> service
    wsm --> api
    wsm --> service

    stratdevkit --> dotnet
    stratdevkit --> wm
    execdevkit --> dotnet
    execdevkit --> wm
    indicdevkit --> dotnet
    indicdevkit --> wm
    indicdevkit --> api
    mddevkit --> dotnet
    mddevkit --> wm

    strategies --> wm
    strategies --> stratdevkit
    execengines --> wm
    execengines --> execdevkit
    indengines --> wm
    indengines --> indicdevkit
    indengines --> mddevkit
    mdengines --> wm
    mdengines --> mddevkit
    mdengines --> api
    workers --> wm
    workers --> api
    examples --> wm
    examples --> api
    examples --> wsm
    examples --> stratdevkit
    examples --> execdevkit
    examples --> indicdevkit
    examples --> mddevkit
    examples -.-> strategies
    examples -.-> execengines
    examples -.-> indengines
    examples -.-> mdengines

    tui --> api
    app --> api
    app --> wm
    app --> wsm

    helm -.-> api
    helm -.-> wm
    helm -.-> wsm
    deploylocal -.-> api
    deploylocal -.-> wm
    deploylocal -.-> wsm
    dockercompose -.-> api
    dockercompose -.-> wm
    dockercompose -.-> wsm
    dockercompose -.-> app

    click dotnet "https://lib.docs.virtufin.com" "virtufin-dotnet docs" _blank
    click openspec "https://specs.docs.virtufin.com" "virtufin-openspec docs" _blank
    click common "https://git.haenerconsulting.com/virtufin/common" "virtufin-common repo" _blank
    click api "https://api.docs.virtufin.com" "virtufin-api docs" _blank
    click service "https://git.haenerconsulting.com/virtufin/service" "virtufin-service repo" _blank
    click wm "https://workmanager.docs.virtufin.com" "virtufin-workmanager docs" _blank
    click wsm "https://websocketmanager.docs.virtufin.com" "virtufin-websocketmanager docs" _blank
    click stratdevkit "https://strategy-devkit.docs.virtufin.com" "virtufin-strategy-devkit docs" _blank
    click execdevkit "https://execution-devkit.docs.virtufin.com" "virtufin-execution-devkit docs" _blank
    click indicdevkit "https://indicator-devkit.docs.virtufin.com" "virtufin-indicator-devkit docs" _blank
    click mddevkit "https://market-data-devkit.docs.virtufin.com" "virtufin-market-data-devkit docs" _blank
    click strategies "https://strategies.docs.virtufin.com" "virtufin-strategies docs" _blank
    click execengines "https://execution-engines.docs.virtufin.com" "virtufin-execution-engines docs" _blank
    click indengines "https://indicator-engines.docs.virtufin.com" "virtufin-indicator-engines docs" _blank
    click mdengines "https://market-data-engines.docs.virtufin.com" "virtufin-market-data-engines docs" _blank
    click workers "https://workers.docs.virtufin.com" "virtufin-workers docs" _blank
    click examples "https://examples.docs.virtufin.com" "virtufin-examples docs" _blank
    click tui "https://tui.docs.virtufin.com" "virtufin-tui docs" _blank
    click app "https://git.haenerconsulting.com/virtufin/app" "virtufin-app repo" _blank
    click site "https://www.virtufin.com" "virtufin site" _blank
    click helm "https://git.haenerconsulting.com/virtufin/helm" "helm repo" _blank
    click deploylocal "https://git.haenerconsulting.com/virtufin/deploy-local" "deploy-local repo" _blank
    click dockercompose "https://git.haenerconsulting.com/virtufin/docker-compose" "docker-compose repo" _blank
    click docs "https://docs.virtufin.com" "docs site (this site)" _blank

Virtufin repos

Repo	What it is	Docs site
virtufin/docs	This site. The central hub — platform overview, concepts, architecture, and this ecosystem map.	docs.virtufin.com
virtufin/common	Shared infrastructure: cross-build Docker image, the canonical versions.env convention, shared Directory.Packages.props patterns, and the shared docs assets (mkdocs-base.yml, stylesheets/common.css, javascripts/mermaid-zoom.js) that every docs site pulls in at build time. Hosts all eleven reusable CI workflows: docs-common, docs-lint-common, docker-common, nuget-common, nuget-library-common, worker-nuget-common, execution-worker-nuget-common, pypi-common, npm-common, protos-common, test-parity-common — including the docs-common.yaml workflow that builds and publishes each repo's docs site.	(no docs site)
virtufin/openspec	The platform's normative specifications: cross-cutting rules (API-mediated pub/sub, CloudEvent envelope), per-service specs (API gateway, worker management, WebSocket proxy, multi-SDK), and operational specs (deployment, CI/CD). Scenario-driven (WHEN/THEN/AND) format.	specs.docs.virtufin.com
virtufin/lib	The .NET 10 library layer: Virtufin.Core (EAV framework, contract traits, DecimalAmount), Virtufin.Base (concrete types: Currency, Cash, Position, Metronome<T>), Virtufin.Data (Variant, FlatBuffers, NATS / WebSocket / Valkey IObservable<T>), Virtufin.Util (time, formatting). The "core" the rest of the platform is built on.	lib.docs.virtufin.com
virtufin/api	The API gateway. The single mediator through which services talk to Dapr (pub/sub, state). Hosts Gateway.InvokeJson, MethodSchema, the dynamic ServiceClient proxy used by the IGatewayClient managed adapter.	api.docs.virtufin.com
virtufin/workmanager	The WorkManager service. The host process for in-process workers. Implements the DotNetDllEngine (managed, via the embedded CoreCLR bridge) and the NativeDllEngine (AOT, via NativeLibrary.Load).	workmanager.docs.virtufin.com
virtufin/websocketmanager	The WebSocketManager service. The proxy for external WebSocket connections (Binance, Alpaca, etc.). Workers talk to it via the API gateway's websocketmanager.* methods (Connect, SendRaw, StartPublish, etc.).	websocketmanager.docs.virtufin.com
virtufin/strategy-devkit	The strategy development kit: the IDecide coalgebra bridge and reusable pieces that turn a strategy into a WorkManager worker. Producer half of the decide/execute loop.	strategy-devkit.docs.virtufin.com
virtufin/execution-devkit	The execution development kit: bridges an IExecutor into a WorkManager worker. Consumer half of the decide/execute loop.	execution-devkit.docs.virtufin.com
virtufin/indicator-devkit	Deploys any IIndicator<TSelf, TSample, TValue> as a standalone WorkManager worker.	indicator-devkit.docs.virtufin.com
virtufin/market-data-devkit	Builds world-scoped market-data workers (MarketDataWorkerBase: the market-data envelope, the exchange's event time) and owns the market-data contracts, starting with the OHLCV candle.	market-data-devkit.docs.virtufin.com
virtufin/strategies	Deployable strategy workers built on the IDecide coalgebra and virtufin-strategy-devkit (e.g. moving-average crossover, C# + Python variants).	strategies.docs.virtufin.com
virtufin/execution-engines	Deployable executor workers (Simulated / Shadow / Live) built on virtufin-execution-devkit. Consumer half of the decide/execute loop's deployed fleet.	execution-engines.docs.virtufin.com
virtufin/indicator-engines	Deployable indicator workers built on virtufin-indicator-devkit (SimpleMovingAverage, LogReturn, ShannonEntropy): fold closed candles into scenario-scoped indicator values.	indicator-engines.docs.virtufin.com
virtufin/market-data-engines	Deployable market-data workers built on virtufin-market-data-devkit (a Binance order-book maintainer, Binance candles) — ingest and maintain market data rather than participating in the decide/execute loop directly.	market-data-engines.docs.virtufin.com
virtufin/workers	Worker source packages — HttpGetWorker is the canonical example. Covers the IGatewayClient abstraction, the build pipeline (managed / native / both), the runtime arch check, the bridge between the WM core and per-worker shims.	workers.docs.virtufin.com
virtufin/examples	Worked examples — dotnet, Python and TypeScript. Verso notebooks take each devkit end to end (write a worker, test it, publish it, deploy it on demo, observe it) and chain the published engines (devkit-pipeline.verso); Python and TypeScript clients call the platform APIs through the gateway. Every example picks its API by a context name near its top ("demo" by default, from contexts.toml). For an AOT-portable worker project, see HttpGetWorker in virtufin/workers.	examples.docs.virtufin.com
virtufin/service	Shared multi-instance coordination library (heartbeat/peer-index, InstanceHeartbeatService) consumed by WorkManager and WebSocketManager for peer discovery and liveness.	(no docs site)
virtufin/tui	Operator dashboard: a Textual-based Python terminal UI that connects to a virtufin-api endpoint.	tui.docs.virtufin.com
virtufin/app	The platform's web app frontend. Consumes the virtufin-openspec domain spec; ships its own Kubernetes deploy config.	(no docs site)
virtufin/site	The public landing page at www.virtufin.com — a single hand-written static page, no framework or build step.	(this is the site itself)
virtufin/helm	The Helm chart that deploys the Virtufin microservices platform with Dapr sidecars on Kubernetes.	(no docs site)
virtufin/deploy-local	Runs the Virtufin backend services natively via dapr run for local dev — no Docker containers for the services themselves, only Dapr-managed sidecars.	(no docs site)
virtufin/docker-compose	Deploys the full Virtufin microservices platform (API + WM + WSM + infra) locally via Docker Compose, with its own dev.yaml/prod.yaml profiles and the same env-var convention (VIRTUFIN_DOCKER_*, VIRTUFIN_PACKAGES_*, etc.).	(no docs site)

How the sites are built

All the docs sites are built with the same toolchain: - MkDocs Material, configured once in common/docs/mkdocs-base.yml: the theme (indigo palette, dark/light toggle, search, code annotations), the markdown extensions, and the shared header and footer. Every site's header shows the repo and a badge with the commit it was built from; the footer shows the build time. - mkdocs_v1.yml is the canonical config filename (mirroring each service's API version, e.g. v1). It starts with INHERIT: mkdocs-base.yml and holds only what is specific to the repo: site name and URL, repo, nav, and the shared common.css / mermaid-zoom assets. A site may override a theme feature list or the markdown extensions (tui does); lists replace the base's. - docs-common.yaml in common/.github/workflows/ is the reusable workflow: it fetches the shared templates and mkdocs-base.yml, fills in the commit and build time, builds, and publishes. Each repo's .github/workflows/docs.yaml calls it with its own docs_repo and mkdocs_config. - docs-lint-common.yaml is the reusable lint workflow for docs PRs. - Hosting: each site is a Cloudflare Pages project, <name>-docs-virtufin-com, served at <name>.docs.virtufin.com (the CNAME file at the docs root names the domain).

A new docs site needs its domain set up once. The workflow creates and deploys the Pages project, but the domain needs two records, without which it doesn't resolve (as for indicator-engines and market-data-devkit until 2026-10-10): 1. a CNAME at DNS Made Easy (zone virtufin.com): <name>.docs → <name>-docs-virtufin-com.pages.dev., TTL 1800; 2. the custom domain <name>.docs.virtufin.com on the Pages project (Cloudflare dashboard or API), which turns active once the CNAME resolves.

The same theme settings are used across every site so a developer can move between them without visual whiplash.