A professional 3D visualization system for tracking the passage of interstellar object 2I/Borisov through our solar system.

Interstellar Tracker is a microservices-based application that provides real-time and time-accelerated visualization of interstellar objects passing through our solar system. Built with Clean Architecture principles, it demonstrates professional .NET development practices suitable for learning and production use.

• 🌠 3D Solar System Visualization - OpenGL-based rendering using Silk.NET
• ⏱️ Time Control - Real-time and accelerated time simulation
• 🔐 Enterprise Authentication - Keycloak integration with social login support
• 📊 Orbital Calculations - Accurate astronomical physics engine
• 🐳 Container-Ready - Full Docker and Kubernetes support
• ✅ Quality Assured - Comprehensive testing and code quality gates
• 📚 Well-Documented - Designed for junior developer onboarding

This project follows Clean Architecture with microservices pattern and event-driven communication:

┌─────────────────────────────────────────────────────────────┐
│                    API Gateway (YARP)                        │
│           Routing • Load Balancing • Telemetry              │
└────────────────────────┬────────────────────────────────────┘
                         │
        ┌────────────────┼────────────────┐
        ▼                ▼                ▼
┌───────────────┐ ┌──────────────┐ ┌─────────────┐
│ CalculationSvc│ │VisualizSvc   │ │ AuthService │
│    :5001      │ │   :5002      │ │   :5003     │
│ • Orbital calc│ │• Trajectories│ │• Keycloak   │
│ • Ephemeris   │ │• Coord. trans│ │• JWT        │
└───────┬───────┘ └──────┬───────┘ └──────┬──────┘
        │                │                 │
        └────────────────┼─────────────────┘
                         ▼
                 ┌───────────────┐
                 │   RabbitMQ    │ (Phase 4)
                 │  Event Bus    │
                 └───────┬───────┘
                         │
            ┌────────────┴────────────┐
            ▼                         ▼
    ┌────────────────┐       ┌────────────────┐
    │ App Insights   │       │   Grafana +    │
    │ + Log Analytics│       │   Prometheus   │
    └────────────────┘       └────────────────┘

Current Status: ✅ API Gateway + CalculationService deployed | ✅ VisualizationService HTTP integration (TDD)

• Domain - Core business models (HyperbolicOrbit, CelestialBody, 2I/Borisov)
• Application - Use cases, CQRS (MediatR), validation (FluentValidation)
• Infrastructure - Azure App Insights, Key Vault, persistence
• Services - Microservices comunicating via HTTP (→ RabbitMQ Phase 4)
• Web - Blazor Server dashboard + Silk.NET 3D rendering

📚 Detailed Architecture: docs/02-architecture/system-overview.md

Target: 0 → Running system in < 30 minutes

• .NET 8.0 SDK (or later)
• Docker Desktop (for infrastructure)
• Git
• VS Code (recommended) or Visual Studio 2022+

# 1. Clone and navigate
git clone https://github.com/YOUR_USERNAME/interstellar-tracker.git
cd interstellar-tracker

# 2. Start infrastructure (Keycloak, RabbitMQ, Prometheus, Grafana)
docker-compose up -d

# 3. Build solution
dotnet build InterstellarTracker.sln

# 4. Run tests
dotnet test

# 5. Start services (VS Code task or manual)
dotnet run --project src/Services/CalculationService/InterstellarTracker.CalculationService
dotnet run --project src/Services/ApiGateway/InterstellarTracker.ApiGateway

• API Gateway: http://localhost:5014/swagger
• CalculationService: http://localhost:5001/swagger
• Health checks: http://localhost:5014/health
• Grafana: http://localhost:3000 (admin/admin)
• RabbitMQ Management: http://localhost:15672 (guest/guest)

📘 Complete Guide: docs/04-development/getting-started.md

• System Overview - High-level architecture, tech stack, deployment
• Microservices - Service catalog, dependencies, API contracts
• Data Flow - Request/event flow, caching strategy
• ADRs - Architecture Decision Records
  • ADR-001: Clean Architecture + Microservices
  • ADR-005: YARP for API Gateway
  • ADR-006: Application Insights
  • ADR-007: CalculationService Integration (TDD) ⭐ NEW

• Getting Started - < 30min setup guide (new developers start here!)
• Coding Standards - C# conventions, SOLID, testing guidelines
• Local Development - Docker Compose, hot reload, debugging
• Git Workflow - Branching, commits, PRs

• Orbital Mechanics - Hyperbolic orbits, Keplerian elements, 2I/Borisov
• Coordinate Systems - J2000, ecliptic, transformations
• Glossary - Astronomical & technical terms

• Monitoring - Application Insights, Grafana, alerts
• Azure Infrastructure - Deployed resources, Terraform
• Troubleshooting - Common issues, health checks

• Roadmap - 7-phase plan to completion
• Contributing - How to contribute (when repo is public)

# Run all tests
dotnet test

# Run with coverage
dotnet test /p:CollectCoverage=true /p:CoverletOutputFormat=opencover

# Generate coverage report
reportgenerator -reports:coverage.opencover.xml -targetdir:coveragereport

# Run only integration tests
dotnet test --filter Category=Integration

• Unit Tests (17) - TrajectoryService business logic with mocked dependencies
• Integration Tests (6) - HTTP client tests using WireMock.Net for mocking external CalculationService
• Test Coverage - Target >80% (Phase 6)

WireMock Integration: Integration tests use WireMock.Net to mock HTTP responses from CalculationService, following best practices:

• CustomWebApplicationFactory - Overrides configuration to point to WireMock server
• CalculationServiceMock - Pre-configured HTTP stubs matching real API contracts
• IAsyncLifetime pattern - Proper lifecycle management with random port assignment

See ADR-007 for TDD implementation details.

docker-compose build

kubectl apply -f k8s/

docker tag interstellar-tracker/api-gateway ghcr.io/YOUR_USERNAME/interstellar-tracker-api-gateway:latest
docker push ghcr.io/YOUR_USERNAME/interstellar-tracker-api-gateway:latest

docker-compose up

See deployment documentation for full Azure setup with:

• Azure Kubernetes Service (AKS)
• Azure Container Registry
• Azure AD B2C for social authentication
• Application Insights for monitoring

We welcome contributions! This project is designed to be learning-friendly.

1. Fork the repository
2. Create a feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'feat: add amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

See CONTRIBUTING.md for detailed guidelines.

Current Phase: 1 - Documentation (~35-40% complete overall)

Progress: ROADMAP.md | Azure: Portal Dashboard

• Current: ~30% (xUnit tests in Domain, Application)
• Target: >80% (Phase 6 - TDD adoption)
• Quality Gate: SonarQube (Phase 5)

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

• 2I/Borisov orbital data - JPL Small-Body Database
• Silk.NET - Modern .NET OpenGL bindings
• Keycloak - Open-source identity and access management
• Clean Architecture - Robert C. Martin's architectural pattern

• Project Maintainer - @YOUR_USERNAME
• Email - eprey27@gmail.com
• Issues - GitHub Issues

Built with ❤️ for learning and exploring the cosmos 🚀