🚀 Syrius: The High-Density Computing Standard

🌍 Universal Deployment

Our architecture based on lightweight containers and native Rust binaries allows Syrius to integrate where your business lives:

• Public Cloud (Azure, AWS, GCP): Optimize instances and reduce your monthly vCPU bill.
• Edge & On-Premise: Maximize performance of old or limited hardware.
• Serverless & Containers: Near-zero startup latencies for ephemeral workflows.

Why the market needs Syrius:

• "Pay for the savings generated, not for idle vCPUs. Syrius reports the real efficiency KPI directly to your financial dashboard."
• "Reduce the latency of your microservices by delegating heavy tasks to a native binary that doesn't suffer from garbage collector (GC) pauses like Java or .NET."
• "Secure hardware anchoring (Node-Locking) to ensure your licenses only run where you authorize."

💮 Technical Manifesto: Syrius High-Density Engine

Syrius Engine is a high-density computing engine designed to reduce operational costs in Azure. It allows delegating critical workloads to an optimized Rust core, achieving savings from 40% in vCPU.

The era of Efficient Computing

In a world where cloud infrastructure costs grow uncontrollably, Syrius is born with a clear mission: Maximize computing density to reduce financial footprint. We are not another software layer. We are an ultra-low latency execution engine built entirely in Rust, designed to integrate at the heart of ERP systems, Artificial Intelligence, and microservices architectures.

Why Syrius?

1. Performance without compromises (Powered by Rust)

By eliminating the Garbage Collector and using manual and safe memory management, Syrius processes workloads with predictable latency. This allows executing more tasks on the same hardware, reducing the need to scale vCPUs in Azure.

2. Military-Grade Cryptographic Security

Each Syrius instance is protected by Ed25519 digital signatures and anchored to hardware via Hardware-ID hashing. Your intellectual property and data are shielded against unauthorized executions.

3. Universal and Transparent Integration

We believe in agility. That's why Syrius exposes a native OpenAPI 3.0 (Swagger) interface. Whether you work with Python, .NET, Go, or Node.js, integration is as simple as a REST call, but with the power of a native binary.

4. Real-Time Savings Telemetry

Syrius not only optimizes but demonstrates value. Our financial telemetry system reports vCPU savings generated in real-time, allowing partners to visualize ROI from the first minute of execution.

💪 Quick Start

Start the engine locally

Copy and execute this command to start your Trial node:

docker run -d -p 8080:8080 -p 3001:3001 syriusengine.azurecr.io/core:v3.1

⚡ Node Health Verification

Once the container is running, verify the internal engine connectivity with the following command:

curl -X GET http://localhost:8080/v1/status

Expected response:

{ "status": "healthy", "engine_pid": 1234, "license": "Active - Enterprise Trial" }

🛠️ Environment Variables Configuration

Syrius is highly configurable. You can tune performance by passing these variables to docker run:

🔑 API Reference

POST /v1/accelerate

This endpoint receives the workload for high-density motor delegation.

Request Body:

{
  "task_id": "string",
  "payload": "string (data to process)"
}

Response (200 OK):

{
  "status": "success",
  "saving": "45%"
}

Field Details:

• task_id: Unique identifier (UUID v4 recommended) for Dashboard traceability.
• payload: Data buffer. Maximum recommended: 50MB per request to maintain latencies <10ms.< /span>

Status Codes and Common Errors:

🐍 Python SDK (AI / Data Science)

import requests

# Configuration
SYRIUS_URL = "http://localhost:8080/v1/accelerate"

def optimize_process(task_id, data):
    response = requests.post(SYRIUS_URL, json={
        "task_id": task_id,
        "payload": data
    })
    return response.json()

# Example:
print(optimize_process("JOB_001", "erp_data_block"))

⚡ .NET SDK (Business Central / ERP)

using System.Net.Http.Json;

public async Task CallSyrius()
{
    using var client = new HttpClient();
    var payload = new { task_id = "TASK_1", payload = "data_buffer" };
    
    var response = await client.PostAsJsonAsync(
        "http://localhost:8080/v1/accelerate", 
        payload
    );
    
    var result = await response.Content.ReadAsStringAsync();
    Console.WriteLine($"Syrius Response: {result}");
}

📊 Business Central (AL Language)

🔌 Architecture for Dynamics 365 / Serverless

Syrius acts as a Compute Sidecar. While Business Central manages business logic, Syrius processes the heavy load in an optimized Rust environment, returning results via JSON instantly.

Advantages:

• Zero Footprint: No installation required on client infrastructure.
• Infinite Scalability: Being Serverless-friendly, Syrius scales according to BC requests.
• Native Auditing: The partner can see how much processing time they're saving for their end client from the central Dashboard.

The Connector for Business Central (AL Language)

In Business Central you don't install anything, you use the HttpClient to delegate calculation to your Azure API. Your BC engineers should create a Codeunit like this:

codeunit 50100 "Syrius Accelerator"
{
    procedure PostToSyrius(Payload: Text): Text
    var
        Client: HttpClient;
        Content: HttpContent;
        Response: HttpResponseMessage;
        Headers: HttpHeaders;
        Result: Text;
        Url: Text;
    begin
        Url := 'https://syrius-core-api.azurecontainerapps.io/v1/accelerate';
        
        Content.WriteFrom('{"task_id": "BC-001", "payload": "' + Payload + '"}');
        Content.GetHeaders(Headers);
        Headers.Remove('Content-Type');
        Headers.Add('Content-Type', 'application/json');
        
        if Client.Post(Url, Content, Response) then begin
            Response.Content().ReadAs(Result);
            exit(Result);
        end;
    end;
}

🔴 Laravel / PHP SDK

Create this file in your project. It's clean, uses Laravel's native HTTP client, and is "Plug & Play".

app/Services/SyriusService.php

<?php

namespace App\Services;

use Illuminate\Support\Facades\Http;
use Illuminate\Support\Facades\Log;

class SyriusService
{
    protected string $baseUrl;

    public function __construct()
    {
        // Your Container App URL in Azure
        $this->baseUrl = config('services.syrius.url', 'http://localhost:8080/v1');
    }

    public function accelerate(string $taskId, string $payload)
    {
        try {
            $response = Http::timeout(10)->post("{$this->baseUrl}/accelerate", [
                'task_id' => $taskId,
                'payload' => $payload,
            ]);

            if ($response->successful()) {
                return $response->json();
            }

            Log::error("Syrius Error: " . $response->status());
            return null;

        } catch (\Exception $e) {
            Log::critical("Syrius Connection Failed: " . $e->getMessage());
            return null;
        }
    }
}

Usage in a Controller:

public function processHeavyJob(SyriusService $syrius)
{
    // Delegate heavy work to the Rust engine
    $result = $syrius->accelerate("BATCH_".time(), "massive_erp_data");
    
    return response()->json([
        'message' => 'Processing optimized',
        'savings_kpi' => $result['saving'] // Ex: "45%"
    ]);
}

Configuration (.env and services.php):

In your .env file:

# Syrius Container App URL in Azure
SYRIUS_ENGINE_URL=https://syrius-core-api.azurecontainerapps.io/v1

In config/services.php:

'syrius' => [
    'url' => env('SYRIUS_ENGINE_URL'),
],

🛡️ Technical Annex: Architecture & Security Core

This annex details the engineering decisions that make Syrius the most robust and efficient engine on the market. Designed under the Zero-Overhead principle, our core guarantees workload integrity and intellectual property security.

1. Execution Engine: Rust & Memory Safety

Unlike managed environments (Java, .NET, Python), Syrius is built entirely in Rust.

• No Garbage Collector (GC): We eliminate random execution pauses, guaranteeing constant latency (P99) even under extreme stress.
• Memory Safety: Memory management is validated at compile time, eliminating buffer overflow vulnerabilities and Memory Leaks.
• Safe Concurrency: Our ownership system allows processing multiple requests in parallel without risk of race conditions.

2. Cryptographic Protocol: Ed25519

For license validation and authenticity, we implement the Ed25519 elliptic curve digital signature algorithm.

• Performance: Signatures are extremely small (64 bytes) and verify in microseconds, ensuring the security audit doesn't penalize API performance.
• Resistance: Ed25519 is immune to many side-channel attacks and doesn't require high-quality random number generators to be secure during verification.

3. Hardware Anchoring (Node-Locking)

Each Syrius node generates a unique fingerprint via Hardware-ID Hashing.

• Algorithm: We use SHA-256 to combine CPU metadata, number of cores, and system architecture.
• Purpose: This hash is cryptographically linked to the license signature. If the binary moves to unauthorized infrastructure, the Guardian blocks execution immediately (Error 401).

4. Telemetry and Transparent Ledger

The financial reporting system uses an asynchronous write model to not block the main processing thread.

• Persistence: Data is consolidated in a PostgreSQL database on Azure, acting as an immutable ledger for vCPU savings calculation.
• KPIs: We report cpu_time_saved_ms and load_factor, enabling real-time audits on return on investment (ROI).

💳 Licensing & Pricing

Syrius offers flexible licensing models designed for any infrastructure scale, from local development to enterprise data centers.

🎯 Syrius Serverless Credits

Acceleration credits for Serverless environments and Dynamics 365 Business Central. No servers to manage. Pay for real usage. 1 Credit = 1 Optimized Transaction. Credits never expire.