AET (Active Expandable Translator) is a system-level programming language and compiler platform for heterogeneous computing, built on GCC.
AET treats execution domains as part of the language semantics, allowing heterogeneous computation to participate in semantic analysis, optimization, and code generation throughout the compiler pipeline.
The goal of AET is:
Write once, run on multiple chips.
Based on the high performance of C and the optimization capabilities of GCC, AET unifies object-oriented programming, generic programming, and heterogeneous computing into one language system.
Over the past decades:
- C solved the performance problem;
- C++ solved the object-oriented programming problem;
- Java solved large-scale software engineering problems;
- CUDA, OpenCL, HIP and others solved parts of heterogeneous computing problems.
However, developers still face:
- One programming model for CPU;
- One programming model for GPU;
- Another programming model for AI accelerators;
- Difficult code reuse between different platforms;
- Difficulty for compilers to perform global cross-platform optimization.
AET aims to change this situation.
AET does not treat heterogeneous computing as a library.
Instead, AET makes heterogeneous computing a part of the language and compiler itself.
In recent years, large language models can help developers:
- Write code
- Complete code
- Fix bugs
- Generate tests
- Refactor programs
Software development is entering the AI-assisted era.
However, whether code is written by humans or generated by AI,
the compiler is still responsible for:
- Semantic analysis
- Program optimization
- Platform adaptation
- Code generation
- Runtime organization
- Heterogeneous scheduling
Especially in the era of heterogeneous computing,
the importance of compilers has not decreased.
It has become even more important.
AI is better at answering:
What should be done?
AET focuses on:
Which chip should run it?
How can it run faster?
How can the entire heterogeneous system be utilized?
Developers or AI only need to describe the algorithm.
AET is responsible for deploying the algorithm to:
- CPU
- GPU
- AI Accelerator
- Future computing devices
Traditional compilers solve:
Source Code
↓
Machine Code
AET aims to further solve:
Algorithm
↓
Heterogeneous Computing System
The future software development model may become:
Developer / AI
↓
AET
↓
CPU + GPU + AI Chip
AET believes:
AI generates code, AET turns code into efficient computation.
AET supports:
- class$
- interface$
- abstract$
- extends$
- implements$
- genericblock$
Helping developers build large software systems.
AET is developed based on GCC.
It inherits GCC's mature:
- Optimization capabilities
- Code generation capabilities
- Multi-platform support capabilities
Allowing developers to continue enjoying C-level performance.
AET is not designed to only support CPU.
It supports:
- CPU
- GPU
- DSP
- AI Accelerator
- Future computing chips
Developers maintain one source code.
The compiler generates code for different platforms.
| Language/Framework | C Compatibility | OOP | Heterogeneous Computing | Complexity | Compiler Optimization |
|---|---|---|---|---|---|
| C | Native | Weak | Manual (CUDA etc.) | Low | Very strong |
| C++ | Excellent | Strong | CUDA / SYCL | High | Strong |
| Rust | General | Medium | Limited | Medium-high | Strong |
| CUDA / HIP | Good | Weak | Single GPU platform | Medium | Medium |
| SYCL / oneAPI | Good | Medium | Multi-platform (limited) | Medium | Medium |
| AET | Native | Strong | Compiler-native | Low | Very strong |
AET is not only a language.
It is also a compiler platform for heterogeneous computing.
Traditional GCC pipeline:
Source
↓
Frontend
↓
GIMPLE
↓
RTL
↓
Assembly
AET introduces an extension layer for heterogeneous platforms between GIMPLE and target code generation.
Through:
- Clone
- Port
- Expand
AET expands the same program to multiple target platforms.
Therefore:
GCC RTL mainly serves a single platform,
while AET's RTL framework serves multiple computing platforms.
This is the foundation of AET's "write once, run on multiple chips" capability.
Current version includes:
- GCC 15.2.0 frontend extension
- Object system
- Generic system
- Eclipse CDT integration
- PTX backend
Currently able to generate:
- NVIDIA GPU PTX code
Future plans:
- AMD GCN
- SPIR-V
Further covering:
- NVIDIA GPU
- AMD GPU
- Vulkan
- OpenCL
and other mainstream heterogeneous platforms.
AET has been used to develop deep learning training frameworks.
Implemented:
- Convolution layer
- MaxPool layer
- AvgPool layer
- Activation layer
- GPU Kernel
- Heterogeneous task scheduling
In CIFAR image classification training tests,
the AET-based training framework achieved about 30%-40% performance improvement compared with the darknet-alex baseline implementation.
#include <stdio.h>
class$ Test{
void hello();
};
impl$ Test{
void hello(){
printf("hello world\n");
}
};
int main(){
Test *t = new$ Test();
t->hello();
return 0;
}AET does not aim to become another C++.
AET focuses on:
- Simplicity
- Extensibility
- Easy optimization
- Heterogeneous computing
AET hopes to:
Keep C performance,
Gain modern software engineering capabilities,
Target future heterogeneous computing platforms.
Please refer to:
INSTALL.md
Current development focuses on:
- Generic system
- PTX backend
- GCN backend
- SPIR-V backend
- Heterogeneous Runtime
- Eclipse CDT plugin
- Compiler optimization
For decades, programming languages have focused on describing algorithms.
AET explores whether future programming languages should also describe where computation belongs.
The long-term goal is to make execution domains a first-class language semantic, allowing compilers to reason about heterogeneous systems from parsing to machine code generation.
GPL v3
(Consistent with GCC)