Independent Software Team — Est. 2025
HONG KONG
22.32°N / 114.16°E

AERO

Write like Python, run like C++.
Aero 1.1.0 is now officially released — fusing C performance with Rust safety.

INDEX 01 / AERO

What is it? A systems programming language.

Aero is a statically typed systems programming language.
Python-like syntax, compiled to native machine code by LLVM.
Generics · Type inference · Borrow checking — memory safety without a garbage collector.

THE LANGUAGE

Write like Python.
Run like C++.

The syntax is close to Python, and underneath, LLVM generates the machine code. Aero 1.1.0 adds Arena memory management and Vec dynamic arrays — done with GC and manual free, as safe as Rust, as fast as C. print is C's printf internally, with identical format placeholders.

$ aero run hello.aero
✓ JIT compiled and executed — output: hello world
$ aero build hello.aero
✓ AOT build complete — standalone exe: hello.exe
✓ 158 integration + 49 type-system tests all passing — TEST SUITE GREEN
arena.aero — Arena memory management
// arena.aero — region allocation, auto-reclaimed
arena MyArena {
data: [i32; 1024];
}
fn main() {
let mut arena = MyArena::new();
arena.data[0] = 42;
print("arena[0] = %lld\n", arena.data[0]);
// freed automatically when leaving scope, no manual free
}
vec.aero — Vec dynamic arrays
// vec.aero — safe dynamic arrays
fn main() {
let v = Vec::new();
v.push(10);
v.push(20);
v.push(30);
print("len = %lld, first = %lld\n", v.len(), v.get(0));
v.sort();
v.reverse();
}

Aero
what's shipped

08 CAPABILITIES
1.1.0 RELEASED
158+ INTEGRATION TESTS
49 TYPE-SYSTEM TESTS / ALL GREEN
01
Arena memory managementRegion allocation · Auto-reclaimed
Done with GC and manual free — region allocations are reclaimed automatically when they leave scope, zero manual memory management.
DONE / Done
→
02
Tensor matrix mathTensor ops · GPU acceleration
Built-in tensor types and matrix ops (matmul) with GPU acceleration — close to data science and numerical computing.
DONE / Done
→
03
Vec dynamic arraysSafe like Rust · Fast like C
Built-in dynamic arrays with push / get / len / sort / reverse out of the box — safe access, high-performance iteration.
DONE / Done
→
04
CollectionsHashMap · BTreeMap · BTreeSet · LinkedList
Common collections out of the box, in both hashed and ordered semantics, to meet many lookup and sorting needs.
DONE / Done
→
05
FFI to Cextern · reuse the C ecosystem
Call C library functions directly via extern, reusing the vast C ecosystem — from strlen to any system library.
DONE / Done
→
06
File IO & command lineread_file · write_file · CLI args
Built-in file read/write and command-line argument parsing — write practical utilities without relying on anyone.
DONE / Done
→
07
Package manageraero-pm · dependency management
Modular development with native dependency management; bring in third-party libraries in one step.
DONE / Done
→
08
LSP supportReal-time diagnostics in VS Code
Language Server Protocol — syntax highlighting and real-time diagnostics in VS Code for a first-class experience.
DONE / Done
→

Development
complete.

The core compiler is ready. 158+ integration tests and 49 type-system tests all pass. Top-level const evaluation and the module system (mod/use/pub/crate) are wired up, and multi-file projects are fully supported in practice — all features in Aero 1.1.0 are complete.

LEXER / PARSER / HIR✓ Done
OWNERSHIP + BORROW CHECK + LIFETIMES✓ Done
TYPE SYSTEM — struct/enum/union/generics/trait✓ Done
const fn compile-time evaluation✓ Done
SELF-HOSTING — HashMap/HashSet self-hosted✓ Done
LLVM 22 JIT + AOT✓ Done
FFI + extern "C"✓ Done
STDLIB — Vec/HashMap/HashSet/Box/FileIO/CLI✓ Done
ARENA — region memory auto-reclaim✓ Done
TENSOR — matrix math + BTreeMap/BTreeSet/LinkedList✓ Done
TOOLCHAIN — fmt/LSP/aero-pm/CLI/VS Code✓ Done
158 integration + 49 type-system tests✓ All green
Top-level const compile-time fill✓ Done
Module system — mod/use/pub/crate✓ Done
1.0.0 — HTTP server + matrix multiplication benchmark✓ Done
UP NEXT · COMING SOON
THENEXTERA

Aero 1.2.0

A brand-new language experience · Coming soon

00DAYS
:
00HOURS
:
00MINS
:
00SECS
RELEASE — Aero 1.1.0

Aero 1.1.0
officially released.

Fusing C performance with Rust safety, now it's easier than ever to get started. AOT + JIT dual modes, built-in Arena memory management, plus generics, Tensor matrix math, and FFI to call C libraries.

01
Arena memory management
Done with GC and manual free — region allocations are reclaimed automatically.
02
Tensor matrix math
Built-in tensor operations with GPU acceleration support.
03
Vec dynamic arrays
As safe as Rust, as fast as C.
04
Collections
HashMap, BTreeMap, BTreeSet, and LinkedList ready out of the box.
05
FFI to C
Directly reuse the vast C ecosystem of libraries.
06
File IO & command line
Write practical utilities without relying on anyone else.
07
Package manager
Modular development with native dependency management.
08
LSP support
Real-time diagnostics in VS Code for a first-class coding experience.
Download Aero 1.1.0 ↓ Try it online now GitCode — Mirror Repository

Who built it?
Serein Team.

Made by an independent team. Aero is developed in the open on GitHub.
Building quietly, measuring precisely — now it's a language's turn.

Try Aero online now ↗ Go to GitHub — open-source repo GitCode — Mirror Repository CSDN Blog — SereinStudio-CN
MADE BY
Serein Team
STATUS
1.1.0 Released
SOURCE
github.com/SereinCin/aero-lang ↗
TESTS
158 integration + 49 type-system
BACK THE TEAM

Independently built,
backed by people like you.

Serein Team is a fully independent software team — no investors, no ads, only a devotion to precision software. If this product has been useful to you, we'd love your support to keep going.

Support us on Aifadian →
FOLLOW
DDiscord Community GGitHub - Aero Source $Aifadian / Sponsor
REDIRECTING