Aero Future is a universal, self‑adaptive build system that can become any build tool you need. It is the evolutionary successor to AeroNova: while AeroNova introduced the concept of a living blueprint that drives deterministic builds, Aero Future extends that into a self‑evolving platform where the blueprint itself can grow, mutate, and adapt to any workload, language, or scale.
Now integrated with the Aero-Calculus, Aero Future natively lowers code syntax into high-precision, zero-allocation topological execution graphs, turning build orchestration into an entirely new paradigm of physical computing.
Traditional build systems (Make, Bazel, Cargo, etc.) are fixed: they have a hard‑coded set of rules, phases, and target formats. Aero Future breaks this mold by treating the entire build lifecycle as a declarative, queryable, and evolvable specification.
- Blueprints are executable: A single
blueprint.aero(orself_host.aero) can describe any build pipeline, from compiling a single‑file script to orchestrating a polyglot microservices monorepo. - Context is king: You can inject external knowledge — source code, documentation, test suites, hardware profiles — as context that the system ingests and uses to shape the build.
- Infinite customizability: Because the system can rewrite its own blueprint and source code, it can retrofit itself to match new requirements without manual intervention.
In short: Aero Future is not a build tool; it is a build‑tool builder.
Aero Future operates as a multi-stage optimization engine driven by five core mechanics:
The blueprint (.aero TOML) is a fluid, declarative specification defining target metrics, workspace constraints, and optimization flags. The engine can rewrite this configuration mid-flight to dynamically specialize itself to your codebase.
The context ingestion layer normalizes all input syntax (Python, Rust, C++, markdown) into a language-agnostic Universal Abstract Syntax Tree. This abstracts raw text code into pure structural geometry.
When a module target uses the custom bytecode compilation, the UAST homomorphically maps to a Holographic Interaction Net (HIN) graph.
- Execution via Annihilation: Computation proceeds via localized graph reductions (Beta-reduction, duplication, erasure) where adjacent node pairs physically collapse.
- Linear Logic Typing: Memory safety is enforced at compilation time via Multiplicative-Exponential Linear Logic (MELL) axioms. Variables are replaced by physical topological edges, achieving zero dynamic heap allocations at runtime.
When local node metrics cross your configured complexity thresholds, the engine represents the compilation matrix as an adjacency graph and executes minimum-cut spectral graph partitioning (via the Fiedler vector). It automatically slices the module apart and generates pristine, decoupled interface API contracts without human intervention.
Every mutation, compile metric, and performance parameter is permanently written to an append-only ledger (context.aero). The runtime uses causal inference to query this static spacetime continuum, executing fast path-integral hot-swaps by replacing active graphs with historically pre-compacted subgraphs.
git clone https://github.com/sys1own/aero-future.git
cd aero-future
pip install -e .
To ingest your workspace contexts, run parameter optimization, and compile targets into native Aero-Calculus topologies (.aeroc binary structures):
python main.py build
To view the generated build dependency Directed Acyclic Graph (DAG) along with the localized HIN port boundaries and linear edge routing paths:
python main.py plan
To activate the multi-objective genetic optimization loop (NSGA-II). This invokes type-safe graph mutations and safe structural crossovers directly on .aeroc configurations to discover hyper-optimized states:
# Syntax: python evolve.py <workspace_dir> <generations> <population_size>
python evolve.py . 5 8
If the compiler intercepts an un-terminated port or broken syntactic dependency during code generation, trigger real-time path re-wiring to resolve the error geometrically:
python main.py heal --path builder_brains/compactor.py
Below is an example of an optimized blueprint.aero orchestrating a native Aero-Calculus target along with complexity scaling boundaries:
[system]
name = "production-scale-polyglot-pipeline"
strategy = "universal-engine"
ephemeral_code = true
[context_registry.core_application]
path = "./src/app_logic.py"
language = "python"
preserve_original_logic = false
compile_target = "aero-calculus" # Lowers UAST directly to interaction net nodes
[scaling]
auto_split_threshold = 120 # Triggers automated spectral mitosis
max_module_complexity = 12
hierarchy_depth = 4
[cortex.nsga2]
population_size = 20
mutation_rate = 0.15
crossover_rate = 0.80
| Capability | Traditional Build Systems (Bazel, Make) | Aero Future (Aero-Calculus Architecture) |
|---|---|---|
| Compilation Path | Text-to-Token linear instruction generation | Homomorphic UAST-to-HIN node graph lowering |
| Memory Allocation | Volatile VM stack frames / manual pointers | Zero-allocation runtime via linear port-binding |
| Optimization Pass | Heavy dead-code and liveness analysis |
|
| Evolution Stability | Fragile text adjustments cause compiler panics | 100% type-safe graph mutations via MELL logic |
| System Refactoring | Manual architecture adjustments | Automated spectral graph bisection via Fiedler vector |
| History Mechanics | Basic caching protocols | Static Block Universe ledger (context.aero) |
MIT License — use it freely, evolve it infinitely.