Open-source mesh, dashboard, and storage for real services

Build, deploy, and observe stateful and stateless services with ToskaMesh.

Stop rebuilding gateway, discovery, auth, and telemetry in every service.

  • For: .NET platform teams shipping microservices.
  • Promise: A standardized runtime surface for routing, discovery, and service lifecycle.
  • Outcome: Ship faster with fewer footguns and consistent ops.
Run the 10-minute demo Dashboard preview Read docs
Gateway auth, dynamic routing, and discovery services.
Dashboard traces, service catalog, and health views.
CLI, Helm, Docker, and Terraform workflows.
Observability
Dashboard
Service health + trace views
ToskaMesh
Control plane
Gateway Discovery Ops Services
Runtime
Stateless Host Stateful Host Telemetry
Simple durable storage
ToskaStore
Durable KV over HTTP/JSON
Service Mesh Dashboard Telemetry Key/Value

Products

Three focused products that work independently or together.

ToskaMesh

A distributed service mesh runtime for .NET 8 that standardizes service lifecycle, routing, security, and observability.

Best fit: .NET teams that want a standardized service runtime (not a sidecar zoo).

Not for you if: you need a polyglot mesh built around Envoy sidecars or require a managed SaaS control plane.

  • Gateway with JWT auth, rate limiting, and request logging.
  • Discovery service for registration, health checks, and events.
  • Runtime hosts for stateful and stateless services.
  • Polly circuit breakers and health-aware load balancing.
  • Toska CLI for init, validate, build/publish, and deploy.
  • Helm, K8s, Dockerfiles, and Terraform deployment assets.
GitHub Getting Started
Observability layer

Dashboard

A dedicated UI for service health, distributed traces, and latency diagnostics across the mesh.

  • Service catalog with health snapshots.
  • Trace explorer with filters and status signals.
  • Waterfall views for end-to-end timing.
  • Correlates gateway requests to mesh RPC spans.
  • Built on the ToskaMesh telemetry pipeline.
Dashboard preview Monitoring setup
Optional or standalone

ToskaStore

Disk-backed KV store with a clean HTTP/JSON surface, built for clarity, persistence, and predictable scaling.

  • Durable AOF + snapshot storage with integrity checks.
  • TTL support, bulk fetch, and optional key listing.
  • Replication follower with snapshot + AOF streaming.
  • Auth tokens and rate limiting for production use.
  • Integrates as the ToskaMesh key/value provider.
GitHub Mesh Guide

How it works

A simple path from service idea to production.

01

Scaffold

2 min · Output: service template and toska.yaml created.

Use the Toska CLI to spin up a stateless or stateful service and get a consistent layout in minutes.

Scaffold guide
02

Run

3 min · Output: gateway returns 200 locally.

Run the control plane with Docker Compose or Helm, then use the Toska CLI to validate, build, and deploy from toska.yaml.

Runtime quickstart
03

Register

2 min · Output: service appears in discovery and gateway routes traffic.

Runtime hosts auto-register with discovery and route through the gateway with built-in health checks.

Registration details
04

Persist

3 min · Output: KV read/write works through the runtime.

Choose ToskaStore or Redis for key/value storage without changing service code.

ToskaStore integration

Capabilities built in

Everything you need to ship, operate, and scale services.

Gateway + Routing

Dynamic routing with Consul-backed config, JWT auth, rate limiting, and request logging.

Discovery + Registry

Discovery service with REST APIs, background health checks, and Consul registry.

Unified runtime hosts

Stateful and stateless hosts share a consistent lifecycle surface and defaults.

Resilience + Circuit Breakers

Polly-backed circuit breakers and hardened load balancing strategies.

Telemetry + Dashboard

Prometheus metrics, tracing, and the Dashboard UI ship with the mesh.

Operational services included

Config, metrics, tracing, and auth services keep cross-cutting concerns consistent.

Stateful persistence options

Plug in ToskaStore or Redis for durable KV without changing service code.

Compared to rolling your own

Eliminates boilerplate for gateway, discovery, auth, telemetry, and runtime hosting in every service.

Compared to general meshes

Gives .NET teams a standardized runtime surface instead of a sidecar-only model.

Use cases

Quick wins that match the runtime’s sweet spot.

Internal microservices baseline

Standardize gateway, discovery, and auth so every team ships the same way.

Stateful service hosting patterns

Run stateful workloads with a consistent runtime that handles lifecycle and telemetry.

KV-backed config or session state

Use ToskaStore or Redis for durable key/value storage with a clean HTTP surface.

Latest ToskaMesh updates

Dashboard joins gateway, discovery, resilience, and deployment tooling in the core mesh.

Dashboard

Service health + traces

A dedicated UI for observing mesh traffic, health, and latency in real time.

  • Service catalog with health snapshots.
  • Trace explorer with filters and status badges.
  • Waterfall timing views for mesh RPC calls.
Gateway service

Dynamic routing + security

YARP-powered routing now adapts to Consul service changes in real time.

  • JWT auth and issuer/audience validation.
  • IP-based rate limiting with proxy awareness.
  • Request/response logging plus health probes.
Discovery service

Registration + health monitoring

Dedicated discovery APIs handle registration, deregistration, and instance lookup.

  • Background health checks and status updates.
  • Consul registry integration with service metadata.
  • Lifecycle events published for mesh consumers.
Resilience + security

Polly circuit breakers

Shared resilience policies are now available throughout the runtime.

  • Configurable break thresholds and durations.
  • Named circuit breakers via DI factories.
  • JWT secret validation hardened at startup.
Deployment stack

Helm, K8s, Docker

Shipping-ready manifests now cover gateway, discovery, and ops services.

  • Helm chart with prod overrides and HPA.
  • Dockerfiles for all control plane services.
  • EKS cost-optimized values and docs.
Dashboard preview

ToskaMesh dashboard

Explore traces, service waterfalls, and latency breakdowns across mesh RPC calls.

These views are generated by the tracing pipeline built into ToskaMesh telemetry.

Service catalog and health snapshots.
Trace search by service, operation, and status.
Waterfall timing with span correlation.
Dashboard screenshots Click a thumbnail to enlarge

Quickstarts

Get running fast with clear, reproducible commands.

ToskaMesh CLI deploy

Use the CLI to scaffold, validate, and deploy from toska.yaml.

toska init inventory-service --type stateless --style host
cd inventory-service
toska validate -f toska.yaml
toska deploy -f toska.yaml

Expected output

  • Gateway returns 200 from /health.
  • Service shows up in discovery.
  • Metrics endpoint responds.
curl -i http://localhost:8080/health
curl -i http://localhost:9090/metrics
CLI reference If this fails, fix-it checklist

Helm control plane

Deploy gateway, discovery, and ops services with the Helm chart.

cd deployments
docker-compose up -d postgres consul rabbitmq
cd ../helm/toskamesh
helm install toskamesh . \
  --set externalServices.postgres.host=host.docker.internal \
  --set externalServices.consul.address=http://host.docker.internal:8500 \
  --set externalServices.rabbitmq.host=host.docker.internal
Helm deployment guide

ToskaStore Docker quickstart

Run the durable KV store locally and write your first record.

docker run --rm -p 4040:4040 ghcr.io/abstractivemachines/toska_store:latest

Expected output

  • HTTP server listens on localhost:4040.
  • Write returns 200 and a JSON payload.
curl -X PUT http://localhost:4040/kv/profile -d '{"name":"Ada"}'
curl http://localhost:4040/kv/profile
Read ToskaStore README If this fails, fix-it checklist

Fix-it checklist

  • Confirm the gateway, registry, and runtime containers are running.
  • Verify ports in toska.yaml match the service host ports.
  • Check logs for auth, discovery, or configuration errors.
  • Ensure metrics endpoints are enabled and reachable.
Troubleshooting resources

Examples

Runnable samples that show the runtime in action.

Start here

Todo Mesh Service

Stateful service with runtime hosts and key/value persistence.

Hello Mesh Service

Stateless runtime consumer with MeshServiceHost and /hello endpoint.

Adder Mesh Service

Base-class style service showing simple routing and registration.

Profile KV Demo

Profile API backed by ToskaStore through the key/value interface.

Mesh RPC Demo

Multi-service RPC workflow that powers the tracing dashboard.

Redis Grain Storage

Orleans grain storage with Redis-backed state.

Project status

Clear expectations for stability, environments, and security.

Stability

MVP: Core gateway, discovery, and runtime hosts are stable. Advanced stateful workflows and ops services are evolving.

Supported environments

Local Docker and Kubernetes via Helm. Terraform assets are available for infrastructure setup.

Security

Report vulnerabilities through GitHub Security. We review and respond with clear status updates.

Security reporting

Docs and links

Deep dives, deployment guides, and architecture notes.

Docs index

Architecture, operations, deployments, and plans.

Runtime quickstart

MeshServiceHost guide for stateless and stateful services.

Kubernetes deployment

Helm-based deployment workflow and troubleshooting.

ToskaStore integration

Configure the key/value provider for mesh services.

Architecture decisions

ADRs covering Orleans, Polly, Consul, and YARP choices.

EKS cost optimization

Terraform and Helm tuning for low-cost dev clusters.

Contact

Get release notes, roadmap drops, and a direct line to the team.

Email

hello@abstractivemachines.com

Updates

Subscribe for release notes and roadmap drops.

Subscribe via email

Community

GitHub Discussions

GitHub

github.com/abstractivemachines

License

Apache 2.0 across ToskaMesh and ToskaStore.