When I first released uα (Unified Assembler), the vision was clear: one assembly language that works across every architecture. Version 26 "Awesome Ada" proved the concept—37 portable instructions running on everything from x86-64 to 8051 microcontrollers. But there was always a deeper goal waiting on the horizon.

Today, I'm excited to share the roadmap for uα Version 27: "Amazing Grace"—and it's going to change everything.

The Ultimate Test: A Compiler Written in Itself

Here's the challenge that defines a truly mature language: can it compile itself?

A Fortran compiler written in Fortran. A Rust compiler written in Rust. A C compiler written in C. This self-hosting capability isn't just a technical milestone—it's proof that a language is powerful enough, expressive enough, and complete enough to handle its most demanding use case.

In 2027, uα will compile uα.

The entire compiler—lexer, parser, code generator, optimizer, and all six architecture backends—will be rewritten in Unified Assembly. No more C99 dependency. Just pure uα code, running on bare metal, producing native executables for any platform.

This is the moment when uα transitions from alpha to beta.

Version 27: "Amazing Grace"

The codename honors Rear Admiral Grace Hopper (1906–1992), the pioneering computer scientist who created the first compiler and championed the idea that programming languages should be readable and portable. She famously said, "It's easier to ask forgiveness than it is to get permission"—a philosophy that applies perfectly to building an experimental assembler that dares to unify six different CPU architectures.

Grace Hopper believed programming should be accessible without sacrificing power. That's exactly what uα strives for.

Building the Foundation: Libraries, Libraries, Libraries

Self-hosting doesn't happen in a vacuum. A compiler needs infrastructure—data structures, memory management, file I/O, string processing, symbol tables, hash maps, error handling. The works.

The work has already begun.

You can see the progress in this active merge request: github.com/el-dockerr/UAlang/pull/1

Dynamic Memory Management

The first major piece is now functional: std_malloc, a complete dynamic memory allocator written entirely in uα.

@IMPORT std_malloc

    ; Allocate 256 bytes on the heap
    MOV R0, 256
    CALL std_malloc.alloc
    ; R0 now contains pointer to allocated memory
    
    ; Use the memory...
    
    ; Free it when done
    CALL std_malloc.free

This isn't a wrapper around the system's malloc(). It's a real allocator—managing free blocks, coalescence, fragmentation—implemented in pure assembly. It runs identically on x86, ARM, RISC-V, and even 8-bit 8051 controllers (with appropriate memory model adjustments).

The fact that this works, and works portably, proves something crucial: uα is ready for serious systems programming.

The Roadmap to Beta

Between now and 2027, the standard library will grow substantially. Here's what's coming:

Core Data Structures

• std_list — linked lists
• std_hashmap — hash tables for symbol lookup
• std_tree — binary trees for syntax parsing
• std_stack — stack management
• std_queue — FIFO queues

Advanced String Handling

• Pattern matching and lexical analysis
• UTF-8 support
• String builders for code generation

File System & I/O

• Enhanced std_iostream with buffering
• Directory traversal
• Binary file manipulation

Each library will be written in uα, tested across all supported architectures, and documented with examples. By late 2027, we'll have everything needed to rewrite the compiler itself.

Why Self-Hosting Matters

You might wonder: why go through all this effort? The current C99 compiler works. Why rewrite it?

Because it proves the language is real.

Right now, uα is a fascinating experiment. After self-hosting, it becomes a legitimate tool. If the language is powerful enough to compile itself—handling complex parsing, optimization passes, and multi-architecture code generation—then it's powerful enough for anything.

It also creates a virtuous cycle: improvements to the language benefit the compiler, which makes development faster, which enables more improvements. The snake eats its tail, and suddenly you have a self-improving ecosystem.

What This Means for You

If you're already experimenting with uα, these new libraries will dramatically expand what you can build. Want to write a text editor? std_string and std_iostream have you covered. A networked embedded device? The memory management and data structures are coming.

If you're watching from the sidelines, 2027 is when uα becomes undeniably real. A self-hosted, cross-platform assembler with a rich standard library isn't a toy project—it's a serious tool for systems programming.

Join the Journey

The merge request is live. The code is open. If you're interested in low-level programming, compiler design, or just want to see how far we can push portable assembly, now is the perfect time to get involved.

Write a library. Port an algorithm. Test the limits. Break things. Report bugs. Suggest optimizations.

By this time next year, when we release uα 27: "Amazing Grace", we'll have hit a milestone that most experimental languages never reach: a fully self-hosting, production-ready compiler that works on six different architectures.

One assembly language. Everywhere. Written in itself.

The future of bare-metal programming is being built right now, one instruction at a time.

---

Follow the progress on GitHub: github.com/el-dockerr/UAlang. The project is released under the GNU General Public License v3.