🌌 Fabric Engine

Reality is fluid. Perspective is everything.

🚧 Work in Progress - Fabric Engine is in active development. The engine is functional but not yet production-ready. APIs may change and documentation is evolving.

Overview

Fabric Engine shatters conventional information hierarchies by creating a framework where reality adapts to your perspective. What appears as an atom from one viewpoint becomes a universe from another—no fixed scales, only fluid perception.

Inspired by games like Star Citizen, Stellaris, and Fractal Block World, Fabric provides the tools to build applications where users can seamlessly traverse multiple scales of reality—from subatomic to cosmic—while maintaining coherent state and perspective-appropriate interactions.

"The mesosphere isn't a fixed scale but the stage where your consciousness currently performs."

Core Concepts

• Quanta - Information particles that shape-shift based on how you observe them
• Scopes - Reality containers that define the rules within your current perspective
• Transformations - Temporal flows that evolve information across states
• Perspectives - The viewpoints that determine your active mesosphere
• Boundaries - The bleeding edges where perception fades into quantum uncertainty or statistical blur

When you shift perspective toward any quantum, it becomes your new mesosphere—complete with its own micro and macro horizons. You don't just see different things; you redefine what "things" are.

Current Features

• Cross-Platform Core: Windows, macOS, and Linux support
• Component System: Type-safe, thread-safe component architecture with variant-based properties
• Event System: Thread-safe event handling with proper propagation and type-safe data
• Lifecycle Management: Thread-safe component lifecycle with validated state transitions
• Plugin Architecture: Thread-safe, dependency-aware plugin system with resource management
• Concurrency Model: Intent-based locking with awareness propagation for deadlock prevention
• Resource Management: Thread-safe resource loading with dependency tracking
• Time System: Multi-timeline temporal processing with variable time flow
• Spatial System: Type-safe vector operations with coordinate space transformations
• WebView Integration: Native webview with bidirectional JavaScript bridge
• Command-Line Interface: Robust argument parsing and validation
• Error Handling: Comprehensive error management system
• Logging System: Multi-level logging with formatting options
• Testing Framework: Comprehensive unit, integration, and thread safety tests
• Modular Architecture: Clean separation of components for maintainability

Implementation

The Fabric Engine is built with a modular architecture that supports perspective-fluid information processing:

• Quantum Core: Fundamentally mutable foundation that adapts to perspective
• Scope System: Defines the rules of reality for particular viewpoints
• Transformation Engine: Enables temporal evolution within and between scopes
• Perspective Manager: Controls active viewpoints and scale relationships

Documentation

View Full Documentation - Complete documentation hub with navigation

Key documents:

• Architecture - Detailed system architecture
• Build Guide - Build instructions for all platforms
• Concurrency - Thread safety and coordination approach
• Roadmap - Development timeline and planned features
• Examples - Code examples and tutorials

Building from Source

Prerequisites

• CMake 4.0 or higher
• C++20 compatible compiler
• Platform-specific development tools

See the Build Guide for detailed platform-specific instructions.

Quick Start

# Clone the repository
git clone https://github.com/yourusername/fabric.git
cd fabric

# Create build directory
mkdir build && cd build

# Configure and build
cmake .. -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Debug
make

# Run the tests
./bin/UnitTests
./bin/IntegrationTests

# Run the application
./bin/Fabric --help

License

MIT License

Contributing

Contributions are welcome! Please see our Contributing Guidelines for details on how to get started.

"To contribute meaningfully, first understand that your perspective shapes what you perceive as problems and solutions. The most valuable insights often come from shifting to a viewpoint where the problem itself is transformed."