Crate strange_loop

Expand description

Strange Loop - Ultra-low-latency agent framework

Strange Loop is a Rust-based agent framework designed for nanosecond-precision coordination and ultra-low-latency systems. It provides deterministic agent execution with sub-microsecond timing guarantees.

§Features

Nano-agent system: Deterministic agents with budget enforcement
Temporal prediction: Computing solutions before data arrives
Lock-free communication: High-performance message passing
SIMD optimizations: Cache-aligned data structures
Nanosecond precision: TSC-based timing for accuracy

§Quick Start

use strange_loop::nano_agent::{NanoScheduler, SchedulerConfig, SchedulerTopology};

let config = SchedulerConfig {
    topology: SchedulerTopology::Mesh,
    run_duration_ns: 100_000_000, // 100ms
    tick_duration_ns: 50_000,     // 50μs
    max_agents: 10,
    bus_capacity: 1000,
    enable_tracing: false,
};

let mut scheduler = NanoScheduler::new(config);
// Add agents and run...

§Performance

Sub-microsecond execution: Agents execute in <1μs
20,000+ Hz coordination: Multi-agent synchronization
Zero allocations: Lock-free, allocation-free hot paths
SIMD acceleration: AVX2-optimized vector operations

§Architecture

Strange Loop implements a hierarchical agent system where nano-agents operate with strict timing budgets and communicate through lock-free message buses. The system is designed for real-time applications requiring deterministic behavior.

Re-exports§

pub use error::LoopError;
pub use error::Result;
pub use nano_agent::NanoAgent;
pub use nano_agent::NanoScheduler;
pub use nano_agent::SchedulerConfig;
pub use nano_agent::SchedulerTopology;
pub use nano_agent::TickResult;
pub use sublinear_solver::SublinearNeumannSolver;
pub use sublinear_solver::SublinearConfig;
pub use sublinear_solver::SublinearNeumannResult;
pub use sublinear_solver::ComplexityBound;
pub use sublinear_solver::JLEmbedding;
pub use types::Context;
pub use types::LoopConfig;
pub use types::Policy;
pub use types::ScalarReasoner;
pub use types::SimpleCritic;
pub use types::SafeReflector;
pub use types::StrangeLoop;
pub use vector3d::Vector3D;

Modules§

consciousness: Consciousness emergence patterns and metrics
error: Error types for the strange-loop crate
lipschitz_loop: Lipschitz-continuous strange loops implementation
nano_agent: Nano-agent system for ultra-low-latency agent orchestration
nano_swarm_enhanced_simple: Simplified enhanced nano-agent swarm using modern concurrent programming
neural_consciousness_simple: Simplified advanced neural consciousness evolution
quantum_container: Quantum-classical hybrid computing containers
quantum_enhanced_simple: Simplified quantum computing simulation with realistic physics
quantum_real
retrocausal: Retrocausal feedback loops - future states influence past computation
self_modifying: Self-modifying strange loops that evolve their own parameters
strange_attractor: Temporal strange attractors with nanosecond precision
sublinear_solver: Sublinear time solver with guaranteed O(log n) complexity
swarm_real
temporal_consciousness: Temporal consciousness implementation combining all components
types: Core types and traits for strange loop implementation
vector3d: Custom Vector3D implementation for strange-loop examples

Constants§

BUILD_INFO: Build information
BUILD_TIME: Build timestamp
GIT_SHA: Git commit hash
VERSION: Version information