I'm a self-taught programmer with over 7 years of experience, starting at age 10 with a bash script on Ubuntu. I specialize in designing compilers and programming languages like C, Rust, and C++ using LLVM, QBE, or GCC, and building scalable web, app, and API backends.

Currently, I'm developing my own LLVM-powered programming language. I'm passionate about tackling complex low-level systems, diving into hardware-software interactions, and pushing system architecture and optimization to new heights.

I’m always eager to innovate, blending creativity with technical precision to craft robust, efficient solutions. I'm constantly open to learning and deepening my understanding of new technologies and concepts. I'm a native Spanish speaker with B2-level English proficiency (CEFR).

The Thrush Programming Language. A system programming language that revolutionizes low-level control, intuitive abstraction for beginners, and limitless IR low-level control for experts.

• The language is largely based on the syntax of its source language, Rust.
• Its name is Thrush, reminiscent of the thrush bird, a relative of the Turdidae family. Its pronunciation differs from the bird's name; it's actually T.. Rush, not Thrush.

Systems languages like C, C++, and Rust have yet to fully explore low-level programming potential, particularly in explicit manipulation of intermediate representations (IRs). Direct IR control empowers developers with seamless, high-level orchestration of assembly-like operations from source code, eliminating the need to resort to raw assembly.

Thrush empowers developers by enabling IR manipulation through language-integrated Low-Level Instructions (LLI), a high-level, streamlined interface for GCC and LLVM intrinsic instructions, while prioritizing beginners with a future memory-safe abstraction layer built atop its powerful, low-level system.

Thrush holds immense promise for bare-metal and embedded systems development through its innovative low-level instructional concepts, particularly its language-integrated Low-Level Instructions (LLI) for seamless IR manipulation with GCC and LLVM intrinsics. While prioritizing simplicity, Thrush will layer a memory-safe abstraction atop its powerful low-level system, making it beginner-friendly. Depending on your needs, you might still choose C, C++, or Rust, but Thrush offers a unique blend of control and accessibility.

• Thrush empowers developers to compile low-level instructions directly to a specified target from source code, enabling precise, architecture-specific optimization with unparalleled ease.

compile @target("armv7e-m") @output("example.s") @asm {
  instr allocated_u8: ptr[u8] = alloc stack!, { u8, @align(4) };
  write allocated_u8, u8 8;
};

• Thrush enables seamless integration of low-level instructions alongside their high-level counterparts, allowing developers to fluidly switch between abstraction levels within the same codebase.

fn main() {
    local number: u8 = 0;

    // Low-level instruction for direct memory access.
    instr loaded_value: u8 = load u8, number;
}

• Thrush enables seamless embedding of linear assembler within the compilation process, offering direct, streamlined control over architecture-specific code generation.

asmfn invoke_exit_syscall() void {
    "mov $$60, %rax",
    "mov $$1, %rdi",
    "syscall"
} { 
    "~{rax}~{rdi}"
}

fn main() {
   invoke_exit_syscall();
}

• Thrush enables seamless compile-time code execution, empowering developers to perform computations and optimizations directly during compilation with a simple, intuitive syntax.

fn comptime_sum(a: u8, a: u8) u16 @compiletime {
  // Non-explicit cast is allowed.
  return a + b;
}

fn main() {
   comptime_sum(15, 15);
}

• And many more unique features when the language base is finished! ~ Kevin Benavides