AETHER is a programming language designed to deliver expressive, deterministic, and elegant execution semantics. Although its conceptual roots play with the notion of endless recursion, the actual implementation emphasizes structural clarity, type safety, and analyzable computation flow.
AETHER is built upon three fundamental principles:
- Layered and Elegant Execution Code structure relies entirely on indentation, producing a clean and readable form without unnecessary syntactic noise.
- Well-Defined Type System The language includes primitive types, composite types, generic constructs, and a semantic resolution mechanism designed to support robust yet flexible typing.
- Deterministic Flow Semantics Despite the thematic reference to infinite recursion, the execution model remains deterministic through controlled flow structures, function resolution rules, and a managed execution environment.
AETHER draws inspiration from C/C++, Java, PHP, Python, and Ruby. However, the language abandons explicit {} block delimiters and instead uses indentation to define structural boundaries.
Represents structural units such as functions, modules, classes, and other block-level constructs. In AETHER, indentation determines block scope.
Covers flow constructs such as if, else, match, for, and while. Indentation defines the boundaries and hierarchical relationships of control paths.
Covers variable declarations, function signatures, class definitions, generic descriptors, and additional semantic constructs. These are tightly integrated with the language’s semantic analyzer.
Includes arithmetic, logical, and compound expressions. All expressions are lowered into the internal IR to ensure consistent and analyzable execution.
AETHER’s type system consists of several categories:
- Built-in Types Includes Char, Boolean, Byte, Int, Float, Double, and other fundamental types mapped to LLVM or another backend.
- Composite Types Supports arrays, tuples, and record-like structures.
- Generic Types Generic constructs are processed through NamedTypeSingle and NamedTypeGeneric, which are resolved into concrete types during semantic analysis.
- User-Defined Types User-defined classes and structures are fully supported. A name-mangling system is used to generate concrete representations for these types.
AETHER’s semantic analysis layer is responsible for:
- Static type resolution
- Type compatibility checks
- Variable scope tracking
- Function, method, and generic analysis
- Name mangling and concrete type generation
This ensures that every unit of code has a fully resolved type suitable for code generation.
The current backend implementation targets LLVM, providing:
- LLVM module and function creation
- Stack memory allocation via alloca
- Basic block creation and management
- Emission of arithmetic, logical, and control instructions
- AST-to-IR lowering through Codegen::visit* methods
The backend is designed to be replaceable or extensible, allowing future support for additional virtual machines or native backends.
package aether.example
from aether.language import {
Int,
Integer,
MutableSequence,
String,
Void
}
public Readonly class PersistentVector<T>:
public function PersistentVector( private MutableSequence<T> data ) -> Void:
""" Construct method of class PersistentVector """
public function push( T value ) -> PersistentVector<T>:
return new PersistentVector([ ...self.data, value ])
public function get( Integer index ) -> T:
if index < 0 || index >= self.length:
raise IndexError( "Index {index} is out of range" )
return self.data[index]
public property length() -> Integer:
return self.data.length
public function main( String args[] ) -> Void:
puts( "Hello World!" )
export {
PersistentVector
}
Give spirit to the developer, no matter how many donations given will still be accepted
paypal.me/hxAri
All AETHER source code is licensed under the GNU General Public License v3. Please see the original document for more details.
