Quick start

Build and run a local two-Component System: one extractor, one Topic, one loader.

What you’ll build

You will scaffold an extractor and a loader, join them in a System, drop an order into a source folder, verify the output file, and follow the run in the dashboard.

FIG Q1Local order flow: source folder → extractor → orders Topic → loader → destination folder.

Before you begin

• The CLI is installed, along with .NET 10 SDK, Docker (running), and Dapr CLI 1.16 (dapr init done)
• A scratch directory you don’t mind throwing away; every command below runs from its root

Windows with WSL

Run every tutorial command inside WSL. Create the scratch directory under your WSL home directory, not under /mnt/c:

mkdir -p ~/intropy-work
cd ~/intropy-work

Docker Desktop must have WSL 2 integration enabled for the distribution you use.

Steps

1. Scaffold the components

intropy int create extractor -n OrderExtractor -o order-extractor \
  --publishes order -s topic=orders -s organization=Fluxia -s empty=false

intropy int create loader -n OrderLoader -o order-loader \
  --subscribes order -s topic=orders -s organization=Fluxia -s empty=false

fetching integrio-intropy/intropy-templates@v0.4.12
created order-extractor from integrio-intropy/intropy-templates@v0.4.12 (template extractor)
created dependency Contracts from template shared-contracts

These commands create two Components that share the order message on the orders Topic. The payload type Order derives from the message name and lives in the shared contract project both Components compile against. Keep the message name and topic identical in both commands.

If scaffolding fails with chmod … .tmp: operation not permitted, move the workspace to a directory under ~/ and run the command again. The error indicates a Windows-mounted workspace, not a template failure.

The first command also creates Contracts/. Each Component records how it was scaffolded in its own .intropy/scaffold.json; the next step reads those records.

2. Create the system

intropy sys create -n OrderFlow

created order-flow from integrio-intropy/intropy-templates@v0.4.12 (template system-host)
assembled system "order-flow": 2 component(s), 1 topic(s), 2 port(s), contracts from Contracts

This scans the scaffold records and creates order-flow/, the system host. Open order-flow/OrderFlowSystem.cs:

order-flow/OrderFlowSystem.cs (excerpt)

builder.AddExtractor("order-extractor")
    .From(Ports.OrderExtractorSource)
    .Publishes(Messages.Order)
    .Calls(Services.Idempotency)
    .Calls(Services.BusinessIncidents);
builder.AddLoader("order-loader")
    .Subscribes(Messages.Order,
        configure: sub => sub
            .IgnoreOthers())
    .To(Ports.OrderLoaderDestination)
    .Calls(Services.Idempotency)
    .Calls(Services.BusinessIncidents);

Messages.Order is defined once in order-flow/Messages.cs, which places the message on its Topic:

order-flow/Messages.cs (excerpt)

public static readonly MessageRef<Order> Order =
    MessageRef<Order>.Define("order", topic: "orders");

This declaration is enough for the host to run the local System.

3. Drop an order in

The extractor sweeps its source folder when the host starts. Seed the folder before running:

cd order-flow
mkdir -p test/order-extractor-source
cp sample-data/sample-order-status-0.json test/order-extractor-source/

The scaffold ships two sample orders. This is the first:

order-flow/sample-data/sample-order-status-0.json

{
  "orderId": "ORD-1001",
  "customerId": "CUST-42",
  "status": "0",
  "orderDate": "2026-05-13T09:30:00Z",
  "lines": [
    { "sku": "SKU-AAA", "quantity": 2, "unitPrice": 19.95 },
    { "sku": "SKU-BBB", "quantity": 1, "unitPrice": 49.00 }
  ]
}

If you have Task installed, task seed runs the same setup and copies both sample orders.

4. Run it

Still in order-flow/:

dotnet run

Docker must be running and dapr init must have completed; without the installed Dapr runtime, each sidecar starts and exits immediately.

Wait for the dashboard line and open the login URL it prints:

Login to the dashboard at http://localhost:15170/login?t=<token>

This is the .NET Aspire dashboard, which the scaffolded host starts alongside your Components. It shows the running resources — your Components, their Dapr sidecars, and the backing containers — and the distributed traces they emit. It is not the same thing as the intropy dashboard command, which is a separate CLI-served view over scaffold records and deployment state; step 5 uses the Aspire one.

Stop any previous dotnet run first. The dashboard, Redis and Microcks ports are fixed, so only one System host runs at a time.

5. Inspect the result

Check the loader output:

cat test/order-loader-destination/ORD-1001.order.json

{"OrderId":"ORD-1001","CustomerId":"CUST-42","LoadedAt":"2026-10-15T08:23:38.50654+00:00","Status":"0"}

The loader names each file after the order and the message (ORD-1001.order.json) and carries the order’s status through.

The dashboard from step 4 shows the run itself. Resources lists the two Components, each with a Dapr sidecar, plus the Redis container backing the Topic and the Microcks container serving the mocked platform services. Three pieces sit under those names:

• Dapr is the runtime the System runs on. Each Component gets a sidecar process, and the Component talks only to its sidecar — publishing to the orders Topic, subscribing to it, and calling the platform services all go through it. That is why the Component code never names a broker, an address, or a credential: those live in the sidecar’s configuration, which is what lets each environment decide what a name resolves to.
• Redis runs in a container as the pub/sub broker the orders Topic resolves to locally.
• Microcks runs in a container serving mocked versions of the platform services (idempotency, business incidents) the Components call.

order-extractor shows Finished between runs: it is a run-to-completion job that sweeps the folder and exits. OrderFlowDevelopment.cs declares development.Rerun("order-extractor").AfterEachRun(TimeSpan.FromSeconds(30)), so the host starts it again 30 seconds after each run. On Traces, open order-extractor: Pipeline.OrderExtractor.Process. The trace follows the order through the extractor’s pipeline steps (Step.Validate, Step.Transform, Step.Send, …), across both sidecars on the orders Topic, and into the loader.

The source file is swept. To send another order, copy it into the source folder while the host is running; the next run picks it up within 30 seconds:

cp sample-data/sample-order-status-1.json test/order-extractor-source/

Continue with the transactional integration tutorial to build the Component pipeline. Use the local cluster path when the System is ready to deploy.