Odin - Hugo Durable Orchestrator

A Temporal/Cadence-style workflow orchestration platform built on Hugo 1.0.0 concurrency primitives.

Status: Phase 1 - Initial Development
The project structure is established. Core implementation is in progress.

What is Odin?

Odin provides durable workflow execution with history replay and distributed task routing. It combines:

• Hugo's elegant concurrency model (WaitGroup, ErrGroup, Channels, Result)
• Temporal-style workflow orchestration (durable execution, history replay, task queues)
• Production-ready observability (OpenTelemetry, Prometheus, Grafana)
• .NET 10 modern runtime with native performance

Quick Links

• Documentation Index
• Getting Started
• Architecture Overview
• Project Structure
• Service Blueprint
• Contributing Guide

Key Features

✅ Durable Workflows - Workflows survive process restarts and replay from history
✅ Deterministic Execution - Guaranteed replay consistency using Hugo primitives
✅ Task Distribution - Efficient lease-aware task routing with heartbeats
✅ Advanced Visibility - SQL or Elasticsearch-based workflow search
✅ Full Observability - OpenTelemetry traces, Prometheus metrics, structured logs
✅ Multi-tenancy - Namespace isolation with RBAC
✅ Production Ready - mTLS, monitoring, operational tooling

Project Structure

Odin/
├── src/                        # Source code
│   ├── Odin.Contracts/        # Shared DTOs and contracts
│   ├── Odin.Core/             # Core utilities
│   ├── Odin.Persistence/      # Data access layer
│   ├── Odin.ControlPlane.Api/ # REST API (port 8080)
│   ├── Odin.ControlPlane.Grpc/# gRPC service (port 7233)
│   ├── Odin.ExecutionEngine.*/# History, Matching, Workers
│   ├── Odin.Sdk/              # Worker SDK
│   ├── Odin.WorkerHost/       # Worker runtime
│   ├── Odin.Visibility/       # Visibility service
│   └── Odin.Cli/              # CLI tool
├── tests/                      # Test projects
├── samples/                    # Example workflows
├── docs/                       # Documentation
└── deployment/                 # Docker, K8s, Helm, Terraform

See Project Structure for details.

Quick Start

Prerequisites

• .NET 10 SDK
• Docker and Docker Compose
• PostgreSQL 14+ (or use Docker Compose)

Run with Docker Compose

git clone https://github.com/df49b9cd/Odin.git
cd Odin
docker-compose up -d

Access:

• gRPC: localhost:7233
• REST API: localhost:8080
• Grafana: http://localhost:3000 (admin/admin)
• Jaeger: http://localhost:16686

Build and Test

dotnet restore
dotnet build
dotnet test

Development Status

Phase 1 (In Progress):

• Project structure and solution setup
• Docker and deployment configurations
• Documentation framework
• Basic project interfaces
• Persistence layer implementation
• History service
• Matching service
• Worker SDK with Hugo integration
• gRPC API implementation
• CLI tool

See Service Blueprint for the full roadmap.

Technology Stack

• Runtime: .NET 10
• Core Library: Hugo 1.0.0 (concurrency primitives)
• APIs: gRPC (Temporal-compatible) + REST
• Persistence: PostgreSQL 14+ or MySQL 8.0.19+
• Visibility: Elasticsearch 8.x or SQL advanced visibility
• Testing: xUnit v3, Shouldly, NSubstitute
• Observability: OpenTelemetry, Prometheus, Grafana, Jaeger
• Deployment: Docker, Kubernetes, Helm

Example Workflow

using static Hugo.Go;
using Hugo;
using Odin.Sdk;

public class OrderWorkflow : IWorkflow<OrderRequest, OrderResult>
{
    public async Task<Result<OrderResult>> ExecuteAsync(
        OrderRequest input,
        CancellationToken cancellationToken)
    {
        return await ExecuteActivity<ValidateOrderActivity>(input)
            .Then(validated => ExecuteActivity<ProcessPaymentActivity>(validated))
            .Then(paid => ExecuteActivity<FulfillOrderActivity>(paid))
            .Recover(error => ExecuteActivity<CompensateOrderActivity>(error))
            .Finally(result => PersistAuditLog(result));
    }
}

See samples/ for complete examples.

Documentation

• Index: docs/README.md for an overview of the available material.
• Guides: Getting Started, Package Management, Test Framework Migration.
• Architecture: Architecture Overview, Service Blueprint.
• Status & Progress: Phase 1 Progress, Setup Summary.
• Planned Areas: API and operations documentation are scaffolded but not yet published.

Contributing

We welcome contributions! See CONTRIBUTING.md for guidelines.

License

This project is licensed under the MIT License - see LICENSE file.

Acknowledgments

• Built on Hugo concurrency primitives
• Inspired by Temporal and Cadence

Support

• GitHub Issues: Create an issue
• Documentation: docs/

---

Built with Hugo and .NET 10