Aestra

🧭 Aestra Architecture Overview

Architecture C++17

Comprehensive overview of Aestra’s modular architecture, covering Core, UI, Audio, and Platform systems.

📋 Table of Contents

🏗️ System Overview

Aestra is built with a clean, modular architecture that separates concerns into distinct subsystems:

┌─────────────────────────────────────────────────────────┐
│                    Aestra Application                     │
└─────────────────────────────────────────────────────────┘
            │                 │
      ┌─────┴─────┐     ┌─────┴─────┐
      │  AestraUI  │     │ AestraAudio│
      │ Framework │     │   Engine  │
      └─────┬─────┘     └─────┬─────┘
            │                 │
      ┌─────┴─────────────────┴─────┐
      │          AestraCore            │
      │  (Platform abstraction,       │
      │   utilities, types)            │
      └───────────────────────────────┘
            │                 │
      ┌─────┴─────┐     ┌─────┴─────┐
      │  Windows  │     │   Linux   │
      │  Platform │     │  Platform │
      └───────────┘     └───────────┘

🧩 Core Modules

AestraCore

Purpose: Foundation layer providing platform abstraction, utilities, and common types.

Location: Aestra-core/, AestraCore/

Key Components:

Public API:

namespace Aestra {
    namespace core {
        // Platform abstraction
        class FileSystem;
        class Thread;
        class Mutex;

        // Utilities
        class Logger;
        class Timer;
    }
}

AestraUI

Purpose: GPU-accelerated custom UI framework with immediate-mode rendering.

Location: AestraUI/

Key Components:

Architecture:

AestraUI/
├── Core/           # Core UI framework
│   ├── NUIWidget   # Base widget class
│   ├── NUIWindow   # Window management
│   └── NUIRenderer # OpenGL rendering
├── Widgets/        # Standard UI widgets
│   ├── NUIButton
│   ├── NUISlider
│   ├── NUITextBox
│   └── NUIDropdown
└── Layout/         # Layout system
    ├── NUILayout
    └── NUIConstraints

Key Features:

AestraAudio

Purpose: Professional audio engine with ultra-low latency processing.

Location: AestraAudio/

Key Components:

Architecture:

AestraAudio/
├── Drivers/
│   ├── AudioDriver         # Abstract driver interface
│   ├── WASAPIDriver        # Windows WASAPI implementation
│   └── ALSADriver          # Linux ALSA implementation
├── Core/
│   ├── AudioEngine         # Main audio engine
│   ├── Track               # Individual audio track
│   ├── AudioBuffer         # Lock-free buffer
│   └── SampleCache         # Waveform caching
└── Processing/
    ├── Mixer               # Audio mixing
    └── Effects             # Audio effects (future)

Key Features:

Muse AI — Post-Beta

AI features are explicitly deferred until after v1 Beta. The roadmap cuts AI features from Beta scope to focus on core DAW stability. Muse integration will resume only after the base product is shippable.

AestraPlat

Purpose: Platform-specific implementations and windowing.

Location: AestraPlat/

Key Components:

🎯 Architecture Principles

1. Separation of Concerns

Each module has a clear, focused responsibility:

2. Dependency Hierarchy

Application
    ↓
AestraUI + AestraAudio + Muse
    ↓
AestraCore
    ↓
AestraPlat (Platform Layer)
    ↓
OS APIs (Windows, Linux, macOS)

Rules:

3. Interface-based Design

Abstract interfaces allow for multiple implementations:

// Abstract audio driver interface
class AudioDriver {
public:
    virtual bool initialize(int sampleRate, int bufferSize) = 0;
    virtual void start() = 0;
    virtual void stop() = 0;
    virtual ~AudioDriver() = default;
};

// Concrete implementations
class WASAPIDriver : public AudioDriver { ... };
class ALSADriver : public AudioDriver { ... };

4. Real-time Constraints

Audio thread is lock-free:

5. Data-Oriented Design

Cache-friendly data layouts for performance:

🔄 Data Flow

Audio Processing Pipeline

[Audio Files]
     ↓
[Sample Loader] → [Sample Cache]
     ↓                    ↓
[Track Manager] → [Waveform Cache]
     ↓
[Audio Mixer]
     ↓
[Audio Driver] → [WASAPI/ALSA]
     ↓
[Hardware Output]

UI Rendering Pipeline

[User Input]
     ↓
[Event Handler]
     ↓
[Widget Tree] → [Layout Engine]
     ↓
[OpenGL Renderer]
     ↓
[Display Output]

Complete System Flow

┌────────────┐     ┌─────────────┐     ┌──────────────┐
│   User     │────→│   AestraUI   │────→│ Application  │
│   Input    │     │   Events    │     │   Logic      │
└────────────┘     └─────────────┘     └──────┬───────┘
                                              │
                   ┌──────────────────────────┘
                   │
        ┌──────────┴──────────┐
        ↓                     ↓
┌───────────────┐     ┌──────────────┐
│  UI Updates   │     │ Audio Engine │
│  (Main Thread)│     │(Audio Thread)│
└───────┬───────┘     └──────┬───────┘
        │                    │
        ↓                    ↓
┌───────────────┐     ┌──────────────┐
│   Renderer    │     │ Audio Driver │
└───────────────┘     └──────────────┘

🧵 Threading Model

Thread Architecture

Aestra uses a multi-threaded architecture with strict thread separation:

┌─────────────────┐
│   Main Thread   │  UI, event handling, application logic
├─────────────────┤
│  Audio Thread   │  Real-time audio processing (lock-free)
├─────────────────┤
│  Loader Thread  │  Async file I/O, sample loading
├─────────────────┤
│  Render Thread  │  GPU rendering (optional, future)
└─────────────────┘

Thread Responsibilities

Main Thread (UI Thread)

Priority: Normal

Audio Thread

Priority: Real-time (highest) Constraints: Lock-free, no allocations, no blocking

Loader Thread

Priority: Background (low)

Thread Communication

Lock-free communication between threads:

// Main → Audio: Commands via lock-free queue
LockFreeQueue<AudioCommand> commandQueue;

// Audio → Main: State updates via atomic flags
std::atomic<bool> isPlaying;
std::atomic<int> currentPosition;

// Example: Start playback
commandQueue.push(AudioCommand::Start);  // Main thread
// Audio thread processes command in callback

Synchronization Primitives

📊 Performance Characteristics

AestraUI

AestraAudio

Memory

🔐 Security Considerations

Public vs Private Code

Public (Aestra-core/):

Private (not in public repo):

Security Measures

📚 Module Dependencies

┌──────────────────────────────────────────────┐
│              Source/ (Application)           │
└──────────────────────────────────────────────┘
        ↓                ↓              ↓
┌──────────────┐  ┌──────────────┐  ┌──────────┐
│   AestraUI    │  │  AestraAudio  │  │   Muse   │
└──────────────┘  └──────────────┘  └──────────┘
        ↓                ↓              ↓
┌──────────────────────────────────────────────┐
│              AestraCore / Aestra-core          │
└──────────────────────────────────────────────┘
        ↓                ↓              ↓
┌──────────────┐  ┌──────────────┐  ┌──────────┐
│  AestraPlat   │  │  Windows API │  │ Linux API│
│ (Win/Linux)  │  │   (WASAPI)   │  │  (ALSA)  │
└──────────────┘  └──────────────┘  └──────────┘

🔮 Future Architecture Plans

v1 Beta Focus (Dec 2026)

  1. Internal Arsenal Plugins — Built-in instruments (Rumble) validated through discovery, persistence, and audible playback
  2. Recording Reliability — Multi-track audio recording with device stress testing
  3. Offline Render/Export — Bounce that matches playback
  4. Plugin Decision Gate — VST3/CLAP hosting ships only if it can be made boringly stable (Phase 4, Sep 2026)

Post-Beta (Deferred)

Scalability

📚 Additional Resources

← Return to Aestra Docs Index

This site is open source. Improve this page.