r/Compilers • • 14h ago

[Hiring] GPU Compiler Engineer – Intel Graphics Compiler (LLVM), Santa Clara, CA (hybrid)

29 Upvotes

Hi r/Compilers,

My team at Intel is hiring a full-time **GPU Compiler Engineer** in Santa Clara, CA (hybrid: part on site, part remote). We build the LLVM-based compilers behind Intel GPUs, used for AI, HPC and data-center workloads.

**What you'd work on**

- Compilers for OpenCL, OpenMP, C for Metal and SYCL / Data Parallel C++

- New compiler features, and code generation and optimization for Intel GPU architectures

- Finding and fixing performance bottlenecks, together with the hardware and architecture teams

- Tooling and automation (Python/shell, CMake, GitHub, Jira) on Linux and Windows

**Minimum qualifications**

- A Master's in CS, CE, EE or a related field plus 3 years of experience, **or** a PhD (completed or expected by May 2028)

- Strong C/C++

- Compiler development: optimizations, front-end translation and back-end code generation

- Computer and graphics architecture

**Nice to have**

- LLVM experience (a big plus)

- GPGPU programming models

**How to apply**

Email **hou-jen.ko@intel.com** with your resume attached as a PDF. Please use exactly this subject line so your application doesn't get missed:

`[GPU Compiler Engineer] Your Name`

A few lines on the compiler work you're proudest of (projects, papers, upstream LLVM patches) are very welcome.

Thanks!


r/Compilers • • 19h ago

Automatic Checking of Compiler Correctness with E-Graphs

Thumbnail stng.substack.com
19 Upvotes

r/Compilers • • 19h ago

Performance of a formally-verified C compiler vs. gcc -O2

Thumbnail ut-infraai.github.io
16 Upvotes

r/Compilers • • 10h ago

Building a compiler from scratch for a programming language I've been designing

3 Upvotes

Hello guys!

I've been designing a new programming language from scratch for the last six months.

It all started with a lifelong desire: **"If C had this..."**

Over time, the specifications evolved considerably and are now mostly finalized, sufficiently mature to move into compiler implementation.

Alongside language design, I've also been developing the compiler from scratch in C.

It's a hand-built compiler. The lexer, error system, and main parser logic are implemented and working. I'm now working through the compiler subsystems one by one.

It's a long journey, but an interesting one!

I'd love to connect with people interested in programming language design, compiler development, and systems programming.

Here is a small snippet of my language.

I'm currently writing small, medium, and large sample programs to test the language design — to test where the langauge design breaks and where it shines, and where improvements are needed.

Over the coming months, I intend to write hundreds of sample programs, designing them from scratch according to the language's rules.

The goal is to put the language through real programming scenarios before moving further with compiler development.

.module tfunc_demo

string char[100] Name

tfunc Name(char[] ptr name open-pass) // generic pointer which can be passed on

strcopy(obj, name) => _

endtfunc

static Name myName("Ghufran Ustad") alias-readonly open-pass

func start;

    ss.con.print("Name: ", myName)

endfunc


r/Compilers • • 13h ago

Mystique - An x86 Metamorphic Compiler

Thumbnail phrack.org
3 Upvotes

r/Compilers • • 23h ago

System Architecture & Subsystem Pipelines for a Zero-Abstraction Lambda Calculus Transpiler & Monotonic Memory Manager & End-to-End Architectural Blueprints: Subsystem Topology of a Zero-Abstraction Lambda Calculus Transpiler & Monotonic Arena Manager

1 Upvotes

Title:

End-to-End Architectural Blueprints: Subsystem Topology of a Zero-Abstraction Lambda Calculus Transpiler & Monotonic Arena Manager

Description:

Here is an exhaustive, granular breakdown of the architectural pipeline mapped out in the subsystem flowcharts for OCHR-X, detailing how abstract symbolic reduction bridges directly down to physical memory allocation and native executable emission[span_0](start_span)[span_0](end_span)[span_1](start_span)[span_1](end_span)[span_2](start_span)[span_2](end_span):

1. Lambda Symbols & Intermediate Representation (IR) Pipeline (lambda_symbols_IR_new)

* Execution Entry & Initialization: The runtime environment boots via `Start proc()`, systematically resolving target offsets and initializing the core event handler (`event handler()`)[span_3](start_span)[span_3](end_span). Argument vectors are ingested and split into value handles (`argv[val]_a_handle`) and character passes (`argv[char]-pass`) for precise parsing[span_4](start_span)[span_4](end_span).

* Symbolic Management & Import: The Intermediate Representation Generation Management unit (IRGM) acts as the central coordinator, interfacing directly with a dedicated `symb importer` and the `lambda IR symbols library` to pull raw tokens into the pipeline[span_5](start_span)[span_5](end_span).

* Evaluation & Error Correction Loop: The parsed structures are passed into the `Symbolic IR generator` and routed directly to GIREVL (the IR Evaluator)[span_6](start_span)[span_6](end_span). The evaluation block continuously validates structural integrity via an explicit conditional check (`if GIR is correct?`)[span_7](start_span)[span_7](end_span). Valid states immediately trigger code generation (`generate IR`), while non-conforming states are safely funneled into IRGERC (Intermediate Representation Generation Error Corrector) to resolve symbolic divergence before re-evaluation[span_8](start_span)[span_8](end_span).

2. Memory Allocator & FFI Pipeline (memory_allocator_manager)

* Program Entry & Header Binding: Execution begins by ingesting command-line arguments and binding compiler functions directly from header references (`pass args to compiler and call functions from in r.h (header)`), feeding straight into the primary compiler driver[span_9](start_span)[span_9](end_span).

* Monotonic Arena Memory Management (PMA): Rather than leaning on standard dynamic heap allocation, the architecture routes memory requests through a specialized PMA / arena memory allocator & mgmt module[span_10](start_span)[span_10](end_span). This coordinates zero-overhead bump pointer allocations and phase resets (`std::pmr::monotonic_buffer_resource`-style dynamics) to eliminate garbage collection latency[span_11](start_span)[span_11](end_span)[span_12](start_span)[span_12](end_span)[span_13](start_span)[span_13](end_span).

* Foreign Function Interface (FFI) & IMACA Evaluation: Foreign function interfaces are transpiled via `FFI (transpiler) via gtms p` and evaluated under IMACA (Intermediate Memory & Scope/Den Evaluation Architecture), generating low-level intermediate representations across control flow graphs, abstract syntax trees, static single assignment (SSIR), or directed acyclic graphs (DAGs) before passing to the library manager (`librmanger`)[span_14](start_span)[span_14](end_span)[span_15](start_span)[span_15](end_span).

* Linker, Emission & Leak Verification: The compiled modules are routed through the system `linker`, generating native object files (`.obj` or `.o`) and assembling a fully realized `executable`[span_16](start_span)[span_16](end_span). Before final output emission, automated validation checks run to confirm memory integrity and detect leaks (`check for memory leaks`)[span_17](start_span)[span_17](end_span).

Thought I’d share the complete structural blueprint for anyone working on custom compiler backends, explicit term-graph substitution engines, or bare-metal runtime architectures. Happy to discuss the interaction between the GIREVL evaluation loops and the memory manager if anyone is exploring similar low-level optimizations!


r/Compilers • • 45m ago

System Architecture & Subsystem Pipelines for a Zero-Abstraction Lambda Calculus Transpiler & Monotonic Memory Manager & End-to-End Architectural Blueprints: Subsystem Topology of a Zero-Abstraction Lambda Calculus Transpiler & Monotonic Arena Manager

Thumbnail gallery
0 Upvotes

Title:

End-to-End Architectural Blueprints: Subsystem Topology of a Zero-Abstraction Lambda Calculus Transpiler & Monotonic Arena Manager

Description:

Here is an exhaustive, granular breakdown of the architectural pipeline mapped out in the subsystem flowcharts for OCHR-X, detailing how abstract symbolic reduction bridges directly down to physical memory allocation and native executable emission[span_0](start_span)[span_0](end_span)[span_1](start_span)[span_1](end_span)[span_2](start_span)[span_2](end_span):

1. Lambda Symbols & Intermediate Representation (IR) Pipeline (lambda_symbols_IR_new)

* Execution Entry & Initialization: The runtime environment boots via `Start proc()`, systematically resolving target offsets and initializing the core event handler (`event handler()`)[span_3](start_span)[span_3](end_span). Argument vectors are ingested and split into value handles (`argv[val]_a_handle`) and character passes (`argv[char]-pass`) for precise parsing[span_4](start_span)[span_4](end_span).

* Symbolic Management & Import: The Intermediate Representation Generation Management unit (IRGM) acts as the central coordinator, interfacing directly with a dedicated `symb importer` and the `lambda IR symbols library` to pull raw tokens into the pipeline[span_5](start_span)[span_5](end_span).

* Evaluation & Error Correction Loop: The parsed structures are passed into the `Symbolic IR generator` and routed directly to GIREVL (the IR Evaluator)[span_6](start_span)[span_6](end_span). The evaluation block continuously validates structural integrity via an explicit conditional check (`if GIR is correct?`)[span_7](start_span)[span_7](end_span). Valid states immediately trigger code generation (`generate IR`), while non-conforming states are safely funneled into IRGERC (Intermediate Representation Generation Error Corrector) to resolve symbolic divergence before re-evaluation[span_8](start_span)[span_8](end_span).

2. Memory Allocator & FFI Pipeline (memory_allocator_manager)

* Program Entry & Header Binding: Execution begins by ingesting command-line arguments and binding compiler functions directly from header references (`pass args to compiler and call functions from in r.h (header)`), feeding straight into the primary compiler driver[span_9](start_span)[span_9](end_span).

* Monotonic Arena Memory Management (PMA): Rather than leaning on standard dynamic heap allocation, the architecture routes memory requests through a specialized PMA / arena memory allocator & mgmt module[span_10](start_span)[span_10](end_span). This coordinates zero-overhead bump pointer allocations and phase resets (`std::pmr::monotonic_buffer_resource`-style dynamics) to eliminate garbage collection latency[span_11](start_span)[span_11](end_span)[span_12](start_span)[span_12](end_span)[span_13](start_span)[span_13](end_span).

* Foreign Function Interface (FFI) & IMACA Evaluation: Foreign function interfaces are transpiled via `FFI (transpiler) via gtms p` and evaluated under IMACA (Intermediate Memory & Scope/Den Evaluation Architecture), generating low-level intermediate representations across control flow graphs, abstract syntax trees, static single assignment (SSIR), or directed acyclic graphs (DAGs) before passing to the library manager (`librmanger`)[span_14](start_span)[span_14](end_span)[span_15](start_span)[span_15](end_span).

* Linker, Emission & Leak Verification: The compiled modules are routed through the system `linker`, generating native object files (`.obj` or `.o`) and assembling a fully realized `executable`[span_16](start_span)[span_16](end_span). Before final output emission, automated validation checks run to confirm memory integrity and detect leaks (`check for memory leaks`)[span_17](start_span)[span_17](end_span).

Thought I’d share the complete structural blueprint for anyone working on custom compiler backends, explicit term-graph substitution engines, or bare-metal runtime architectures. Happy to discuss the interaction between the GIREVL evaluation loops and the memory manager if anyone is exploring similar low-level optimizations!


r/Compilers • • 13h ago

Building a compiler from scratch for a programming language I've been designing

0 Upvotes

Hello guys!

I've been designing a new programming language from scratch for the last six months.

It all started with a lifelong desire: **"If C had this..."**

Over time, the specifications evolved considerably and are now mostly finalized, sufficiently mature to move into compiler implementation.

Alongside language design, I've also been developing the compiler from scratch in C.

It's a hand-built compiler. The lexer, error system, and main parser logic are implemented and working. I'm now working through the compiler subsystems one by one.

It's a long journey, but an interesting one!

I'd love to connect with people interested in programming language design, compiler development, and systems programming.

Here is a small snippet of my language.

I'm currently writing small, medium, and large sample programs to test the language design — to test where the langauge design breaks and where it shines, and where improvements are needed.

Over the coming months, I intend to write hundreds of sample programs, designing them from scratch according to the language's rules.

The goal is to put the language through real programming scenarios before moving further with compiler development.

.module tfunc_demo

string char[100] Name

tfunc Name(char[] ptr name open-pass) // generic pointer which can be passed on

strcopy(obj, name) => _

endtfunc

static Name myName("Ghufran Ustad") alias-readonly open-pass

func start;

ss.con.print("Name: ", myName)

endfunc


r/Compilers • • 23h ago

Together Compiler: Continual Compilation for AI Inference

Thumbnail arxiv.org
0 Upvotes