This page provides a comprehensive guide to the Manifold monorepo directory layout, its 16 constituent projects, target frameworks, key dependencies, and tooling choices. It serves as the essential orientation reference for contributors who need to understand where code lives, how projects relate to each other, and what technologies underpin the build and runtime systems.

Manifold is organized as a single Git repository containing four library packages under src/, four sample applications under samples/, five test projects under tests/, two benchmark projects under benchmarks/, and a set of PowerShell build scripts under build/. For the high-level architectural relationships between the four core packages, see Architecture Overview. For build automation details, see Build System and Scripts.

Manifold/
├── .editorconfig                # Code style rules
├── .github/workflows/           # CI/CD pipelines (ci.yml, publish.yml)
├── .artifacts/                  # Build outputs (packages, benchmarks, tests)
├── assets/                      # Logo and benchmark assets
├── benchmarks/                  # Performance benchmark projects
├── build/                       # PowerShell build scripts
├── samples/                     # Sample host applications
├── src/                         # Core library source code
├── tests/                       # Unit and integration test projects
├── Directory.Build.props        # Shared MSBuild properties
├── Directory.Build.targets      # Shared MSBuild targets
├── global.json                  # .NET SDK version pinning
├── Manifold.slnx                # Solution file (XML format)
├── xunit.runner.json            # xUnit runner configuration
├── LICENSE                      # MIT license
├── README.md                    # Project readme (English)
├── README.ja.md                 # Project readme (Japanese)
├── CONTRIBUTING.md              # Contribution guidelines
└── THIRD_PARTY_NOTICES.md       # Third-party license notices

Sources: Manifold.slnx:1-21, Directory.Build.props:1-34, global.json:1-9

flowchart TD
    Root["Manifold Repository"]
    Src["src/"]
    Tests["tests/"]
    Samples["samples/"]
    Bench["benchmarks/"]
    Build["build/"]
    CI[".github/workflows/"]
    Artifacts[".artifacts/"]

    Root --> Src
    Root --> Tests
    Root --> Samples
    Root --> Bench
    Root --> Build
    Root --> CI
    Root --> Artifacts

    Src --> M["Manifold"]
    Src --> MC["Manifold.Cli"]
    Src --> MG["Manifold.Generators"]
    Src --> MM["Manifold.Mcp"]

    Tests --> T1["Manifold.Tests"]
    Tests --> T2["Manifold.Cli.Tests"]
    Tests --> T3["Manifold.Generators.Tests"]
    Tests --> T4["Manifold.Mcp.Tests"]
    Tests --> T5["Manifold.Samples.Tests"]

    Samples --> S1["Samples.Operations"]
    Samples --> S2["Samples.CliHost"]
    Samples --> S3["Samples.McpStdioHost"]
    Samples --> S4["Samples.McpHttpHost"]

    Bench --> B1["Manifold.Benchmarks"]
    Bench --> B2["Mcp.Benchmarks"]

The solution file Manifold.slnx organizes projects into three solution folders: /src/, /tests/, and /samples/. The two benchmark projects reside under benchmarks/ but are not included in the solution file (they are built independently).

Sources: Manifold.slnx:1-21

Manifold uses two target frameworks across its projects:

• net10.0 — The primary target for all library, test, sample, and benchmark projects. The SDK version is pinned to 10.0.101 with latestFeature roll-forward policy in global.json.
• netstandard2.0 — Used exclusively by Manifold.Generators, the source generator project. This is required because Roslyn analyzer/generator assemblies must target netstandard2.0 to be loaded by the compiler.

The Manifold.Generators project explicitly overrides the default TargetFramework from Directory.Build.props (which sets net10.0) with netstandard2.0 in its own .csproj.

Sources: global.json:1-9, Directory.Build.props:3, Manifold.Generators.csproj:3

The foundational package defining operation contracts, attributes, descriptors, and binding primitives. All other Manifold packages depend on this.

Source files:

Sources: Manifold.csproj:1-19, src/Manifold/ directory listing

CLI binding and fast invocation runtime. Depends on Manifold core.

Source files:

Sources: Manifold.Cli.csproj:1-22

Incremental C# source generator targeting netstandard2.0. Analyzes [Operation]-attributed code and emits registry, invoker, and catalog source files at compile time.

Single source file:

The project is configured as a Roslyn component (IsRoslynComponent=true) and packages its output DLL into the analyzers/dotnet/cs NuGet folder rather than as a standard library reference (IncludeBuildOutput=false).

Sources: Manifold.Generators.csproj:1-45, OperationDescriptorGenerator.cs:1-30

MCP binding and invocation runtime. Depends on Manifold core and the ModelContextProtocol SDK.

Source files:

Sources: Manifold.Mcp.csproj:1-27

flowchart TD
    M["Manifold<br/>(Core Contracts)"]
    MG["Manifold.Generators<br/>(Source Generator)"]
    MC["Manifold.Cli<br/>(CLI Runtime)"]
    MM["Manifold.Mcp<br/>(MCP Runtime)"]
    SO["Samples.Operations"]
    SCH["Samples.CliHost"]
    SSH["Samples.McpStdioHost"]
    SHH["Samples.McpHttpHost"]
    BM["Manifold.Benchmarks"]
    BMM["Mcp.Benchmarks"]

    MC --> M
    MM --> M
    MG -.->|"analyzes attributes from"| M

    SO --> M
    SO --> MC
    SO --> MM
    SO -.->|"analyzer ref"| MG

    SCH --> MC
    SCH --> SO

    SSH --> SO
    SHH --> SO

    BM --> M
    BM --> MC
    BM -.->|"analyzer ref"| MG

    BMM --> M
    BMM --> MM
    BMM -.->|"analyzer ref"| MG

Solid arrows represent project references; dashed arrows represent analyzer (source generator) references.

All test projects share common configuration from Directory.Build.props via the IsManifoldTestProject property, which enables the Microsoft Testing Platform runner, sets OutputType to Exe, and adds shared test dependencies.

The Directory.Build.targets file enforces that every test project must define a CoverageThreshold property; the build fails if this is missing. Coverage is collected via coverlet.MTP version 8.0.0.

Sources: Directory.Build.props:18-33, Directory.Build.targets:13-17, Manifold.Tests.csproj:1-18, Manifold.Samples.Tests.csproj:1-15

For comprehensive testing documentation, see Testing Strategy.

The samples demonstrate how to wire Manifold into host applications. They share a common operations library (Manifold.Samples.Operations) that defines example operations consumed by three different host configurations.

Sources: Manifold.Samples.Operations.csproj:1-14, Manifold.Samples.CliHost.csproj:1-12, Manifold.Samples.McpStdioHost.csproj:1-10, Manifold.Samples.McpHttpHost.csproj:1-10

For walkthroughs of the sample hosts, see Sample — CLI Host and Samples — MCP Hosts (Stdio and HTTP).

Both use BenchmarkDotNet 0.15.8 and reference the Manifold source generator as an analyzer. Benchmark results are stored in .artifacts/benchmark-output/.

Sources: Manifold.Benchmarks.csproj:1-19, Manifold.Mcp.Benchmarks.csproj:1-20

For detailed benchmark analysis, see Performance and Benchmarks.

The build/ directory contains PowerShell scripts that automate all development workflows.

The build.ps1 script selectively builds only projects under src/ and samples/ directories by parsing the solution XML. The pack.ps1 script packages only src/ projects into .artifacts/packages/.

Sources: build.ps1:1-40, pack.ps1:1-55

For full build system documentation, see Build System and Scripts. For architecture validation details, see Architecture Validation and Code Quality.

See CI/CD and Release Pipeline for details.

Sources: Manifold.Mcp.csproj:20, Manifold.Generators.csproj:27-28, Directory.Build.props:25-29, Manifold.Benchmarks.csproj:8-10, Manifold.Mcp.Benchmarks.csproj:8-10

Applies to all projects in the repository and sets shared defaults:

<PropertyGroup>
    <TargetFramework>net10.0</TargetFramework>
    <LangVersion>latest</LangVersion>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
    <WarningsAsErrors>$(WarningsAsErrors);nullable</WarningsAsErrors>
    <EnforceCodeStyleInBuild>true</EnforceCodeStyleInBuild>
    <AnalysisLevel>latest-recommended</AnalysisLevel>
    <EnableNETAnalyzers>true</EnableNETAnalyzers>
    <Deterministic>true</Deterministic>
    <GenerateDocumentationFile>true</GenerateDocumentationFile>
    <RestorePackagesWithLockFile>true</RestorePackagesWithLockFile>
</PropertyGroup>

Key policies:

• Warnings as errors — All warnings, including nullable reference warnings, are treated as errors.
• Deterministic builds — Ensures reproducible build output.
• Code style enforcement — EnforceCodeStyleInBuild combined with .editorconfig rules enforces consistent formatting at build time.
• Lock files — RestorePackagesWithLockFile ensures reproducible NuGet restores.

Sources: Directory.Build.props:1-16

Provides two shared behaviors:

1. NuGet packaging — Packable projects automatically include README.md and LICENSE in the package.
2. Coverage threshold enforcement — Test projects must define CoverageThreshold; the build fails if this property is missing.

Sources: Directory.Build.targets:1-18

The .editorconfig enforces C# style rules including:

• File-scoped namespaces (error severity)
• Explicit accessibility modifiers (error severity)
• No unused using directives (error severity)
• Allman brace style
• UTF-8 encoding with CRLF line endings

Sources: .editorconfig:1-30

The .artifacts/ directory contains build outputs organized by purpose:

All four source projects under src/ are configured as NuGet packages:

The Manifold.Generators package is structured differently from the other three: its compiled DLL is placed in analyzers/dotnet/cs/ within the NuGet package (as required for source generators), and a placeholder _._ file is placed in lib/netstandard2.0/ to satisfy NuGet conventions without shipping a runtime assembly.

<None Include="_._" Pack="true"
      PackagePath="lib/netstandard2.0" Visible="false" />
<None Include="$(OutputPath)$(AssemblyName).dll" Pack="true"
      PackagePath="analyzers/dotnet/cs" Visible="false" />

Sources: Manifold.Generators.csproj:30-44, Manifold.csproj:6-18

flowchart TD
    SDK[".NET SDK 10.0.101"]
    Lang["C# Latest"]
    Roslyn["Roslyn 4.14.0"]
    XUnit["xUnit v3 + MTP"]
    BDN["BenchmarkDotNet 0.15.8"]
    Coverlet["coverlet.MTP 8.0.0"]
    PS["PowerShell Scripts"]
    GHA["GitHub Actions"]
    EdCfg[".editorconfig"]
    NuGet["NuGet Packaging"]

    SDK --> Lang
    SDK --> Roslyn
    Roslyn --> |"Source Generation"| MG["Manifold.Generators"]
    Lang --> |"Build"| PS
    PS --> |"CI/CD"| GHA
    XUnit --> |"Testing"| Coverlet
    BDN --> |"Benchmarks"| PS
    EdCfg --> |"Code Style"| PS
    PS --> |"Pack"| NuGet

• Home — Project overview and navigation index
• Architecture Overview — High-level system architecture and package relationships
• Core Contracts — Manifold Package — Core API documentation
• Source Generator — Manifold.Generators — Generator pipeline details
• CLI Runtime — Manifold.Cli — CLI dispatch pipeline
• MCP Runtime — Manifold.Mcp — MCP integration surface
• Build System and Scripts — PowerShell build automation
• CI/CD and Release Pipeline — GitHub Actions workflows
• Testing Strategy — Test organization and coverage enforcement
• Performance and Benchmarks — Benchmark infrastructure and results
• Architecture Validation and Code Quality — Code quality enforcement
• Sample — CLI Host — CLI host sample walkthrough
• Samples — MCP Hosts (Stdio and HTTP) — MCP host sample walkthroughs
• Sample Operations Reference — Shared sample operations catalog