I am a self-taught developer with over 7 years of experience. I specialize in designing and building compilers using code generators such as LLVM, GCC, or Cranelift for the creation of modern C compilers or for new programming languages. In addition to this, I have in-depth knowledge of creating scalable backends for web applications and APIs.

Currently, I am developing my own systems programming language using code generators such as LLVM and GCC. I am passionate about tackling complex low-level systems, delving into hardware-software interactions, and taking systems architecture and optimization to new heights.

I am always willing to innovate, combining creativity with technical precision to create robust and efficient solutions. I am always open to learning and deepening my understanding of new technologies and concepts. I am a native Spanish speaker with a B2 level of English (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