CrossTL: A Universal Programming Language Translator with Unified Intermediate Representation

TL;DR

CrossTL introduces a universal programming language translator using a single intermediate representation, enabling bidirectional translation across multiple languages and graphics APIs, simplifying multi-language support and deployment.

Contribution

It presents a unified IR and modular architecture that supports diverse programming languages and graphics APIs, facilitating easy addition of new languages with minimal effort.

Findings

Successful compilation and execution across all supported backends

Effective translation between multiple programming languages and graphics APIs

Demonstrated extensibility and practical viability of the framework

Abstract

We present CrossTL, a universal programming language translator enabling bidirectional translation between multiple languages through a unified intermediate representation called CrossGL. Traditional approaches require separate translators for each language pair, leading to exponential complexity growth. CrossTL uses a single universal IR to facilitate translations between CUDA, HIP, Metal, DirectX HLSL, OpenGL GLSL, Vulkan SPIR-V, Rust, and Mojo, with Slang support in development. Our system consists of: language-specific lexers/parsers converting source code to ASTs, bidirectional CrossGL translation modules implementing ToCrossGLConverter classes for importing code and CodeGen classes for target generation, and comprehensive backend implementations handling full translation pipelines. We demonstrate effectiveness through comprehensive evaluation across programming domains, achieving successful compilation and execution across all supported backends. The universal IR design enables adding new languages with minimal effort, requiring only language-specific frontend/backend components. Our contributions include: (1) a unified IR capturing semantics of multiple programming paradigms, (2) a modular architecture enabling extensibility, (3) a comprehensive framework supporting GPU compute, graphics programming, and systems languages, and (4) empirical validation demonstrating practical viability of universal code translation. CrossTL represents a significant step toward language-agnostic programming, enabling write-once, deploy-everywhere development.

Tables

Table 1. Table 1: Feature coverage across target languages. ✓= fully supported through universal translation patterns, ∘ \circ = supported with language-specific adaptations. Additional languages include HIP, Mojo, and Slang with similar coverage patterns.

Feature Category	CUDA	Metal	Rust	DirectX	OpenGL	Vulkan
Basic Syntax	✓	✓	✓	✓	✓	✓
Control Flow	✓	✓	✓	✓	✓	✓
Functions	✓	✓	✓	✓	✓	✓
Arrays	✓	✓	✓	✓	✓	✓
Structures	✓	✓	✓	✓	✓	✓
Shaders	✓	✓	$\circ$	✓	✓	✓
Compute Kernels	✓	✓	$\circ$	✓	✓	✓
Memory Buffers	✓	✓	✓	✓	✓	✓

Full text

Keywords Programming Language Translation  $\cdot$ Intermediate Representation  $\cdot$ Cross-Platform Development  $\cdot$ GPU Programming  $\cdot$ Compiler Design

1 Introduction

The proliferation of programming languages and computing platforms has created a significant challenge for developers who must often maintain equivalent functionality across multiple languages. This challenge is particularly acute in domains such as high-performance computing, graphics programming, and cross-platform development, where performance constraints and platform-specific features necessitate the use of different programming languages [13, 19].

Consider a graphics application developer who needs to support multiple platforms: CUDA for NVIDIA GPUs, HIP for AMD GPUs, Metal for Apple devices, DirectX for Windows, and OpenGL for cross-platform compatibility. Traditional approaches require implementing the same algorithms multiple times, leading to increased development costs, maintenance overhead, and potential inconsistencies between implementations [21, 5].

Existing solutions to this problem typically fall into two categories: (1) platform abstraction layers that provide a unified API but may sacrifice performance or platform-specific features, and (2) source-to-source translators that convert between specific language pairs [2]. However, these approaches suffer from scalability issues as the number of supported languages grows, requiring O(n²) translators for n languages in the worst case.

We propose CrossTL (Cross-Translation Language), a universal programming language translator that addresses these limitations through a unified intermediate representation called CrossGL (Cross Graphics Language). Our approach reduces the translation problem from O(n²) to O(n) by introducing a single intermediate language that captures the essential semantics of multiple programming paradigms.

1.1 Contributions

Our work makes the following key contributions:

Universal Intermediate Representation: We design CrossGL, a language-agnostic intermediate representation that unifies concepts from GPU compute languages (CUDA, HIP), graphics shading languages (GLSL, HLSL, Metal), and systems programming languages (Rust, Mojo). 2. 2.

Modular Translation Architecture: We present a three-stage translation pipeline consisting of language-specific frontends, a universal intermediate representation, and target-specific backends, enabling easy addition of new languages. 3. 3.

Extensible Language Framework: Our system provides a comprehensive framework for supporting diverse programming languages spanning different domains and paradigms, with the architecture designed to accommodate emerging languages and evolving language features. 4. 4.

Empirical Validation: We evaluate CrossTL across diverse programming domains, demonstrating successful compilation and execution across all supported backends, with comprehensive test coverage including complex features like multi-dimensional arrays, control flow, and function definitions.

1.2 Paper Organization

The remainder of this paper is organized as follows. Section 2 discusses related work in code translation and intermediate representations. Section 3 presents the overall architecture of CrossTL and the design of the CrossGL intermediate representation. Section 4 details the implementation of language frontends and backends. Section 5 presents our experimental evaluation. Section 6 discusses limitations and future work. Section 7 concludes the paper.

2 Related Work

2.1 Source-to-Source Translation

Source-to-source translation, also known as transpilation, has been extensively studied in the compiler literature [14]. Traditional approaches typically focus on translating between specific language pairs. For example, TypeScript to JavaScript [3], or C/C++ to Rust [16]. While effective for specific use cases, these approaches do not scale well to multiple languages.

Recent work has explored more general approaches to source-to-source translation. The RISE compiler [19] uses a functional intermediate representation for generating high-performance GPU code, but focuses primarily on array computations. The MLIR framework [11] provides infrastructure for building domain-specific intermediate representations, but requires manual implementation of translation rules between dialects. Modern GPU computing platforms like CUDA [4], HIP [1], and Metal [8] each provide their own programming models, creating fragmentation that CrossTL addresses through unified translation.

2.2 Universal Intermediate Representations

Several projects have attempted to create universal intermediate representations for specific domains. LLVM IR [10] serves as a universal intermediate representation for systems programming languages, enabling optimization and code generation across multiple architectures. However, LLVM IR is designed for traditional CPU architectures and does not capture high-level constructs needed for GPU programming or domain-specific languages.

The GAST (Generic Abstract Syntax Tree) approach [12] proposes a universal AST representation for cross-language analysis, but focuses on static analysis rather than code generation. Similarly, the MLIR ecosystem [11] provides a framework for domain-specific IRs but requires significant effort to implement translation between different dialects.

2.3 GPU Programming Abstractions

Several frameworks have attempted to provide cross-platform GPU programming abstractions. SYCL [15] provides a single-source C++ programming model for heterogeneous computing, but requires specialized compilers and runtime support. OpenCL [20] offers a cross-platform parallel computing framework, but developers must still write platform-specific kernel code. Modern shading languages like Slang [6] provide extensible real-time shading systems, while emerging AI-focused languages like Mojo [9] target high-performance computing with Python compatibility.

More recently, projects like Futhark [7] and Lift [18] have explored functional approaches to GPU programming, automatically generating efficient code for different platforms. However, these approaches require learning new programming paradigms and cannot easily incorporate existing code written in imperative languages.

2.4 Language-Oriented Compiler Design

Recent work in compiler design has emphasized the benefits of language-oriented approaches that treat intermediate representations as first-class programming languages with formal semantics [17]. The Shine compiler demonstrates how functional and imperative IRs can be composed to separate optimization concerns from code generation [17].

Our work builds on these insights by designing CrossGL as a complete programming language with well-defined semantics, rather than a simple data structure for representing code. This approach enables more sophisticated transformations and optimizations while maintaining correctness.

3 Architecture

CrossTL employs a three-stage translation architecture designed to maximize modularity and extensibility while minimizing the complexity of adding new languages. Figure 1 illustrates the overall system architecture.

3.1 Design Principles

Our architecture is guided by the following design principles:

Modularity: Each language frontend and backend is implemented as an independent module, enabling parallel development and easy maintenance. 2. 2.

Extensibility: Adding support for a new language requires implementing only the frontend parser and backend code generator, without modifying existing components. 3. 3.

Semantic Preservation: The translation process preserves the semantic meaning of programs while adapting to syntactic differences between languages. 4. 4.

Performance Transparency: The intermediate representation maintains sufficient high-level information to enable target-specific optimizations.

3.2 Frontend: Language-Specific Parsing

The frontend stage is responsible for parsing source code written in various programming languages into a common abstract syntax tree (AST) representation. Each supported language has a dedicated lexer and parser implemented using established parsing techniques.

3.2.1 Lexical Analysis

Our lexical analyzers tokenize source code according to language-specific rules. The design accommodates diverse language features: CUDA-specific keywords like global and device, Metal Shading Language constructs like kernel and vertex, Rust’s ownership syntax, and Mojo’s AI-oriented constructs.

The lexical analysis phase handles:

• •

Language-specific keywords and operators

• •

Identifier naming conventions

• •

Literal representations (integers, floats, strings)

• •

Comment syntax variations

• •

Whitespace and delimiter handling

3.2.2 Syntactic Analysis

Our parsers convert token streams into language-specific ASTs using recursive descent parsing with careful handling of language-specific syntactic features. Each parser implements language-specific grammar rules while producing ASTs that conform to a common interface.

Key parsing challenges addressed include:

• •

Operator precedence and associativity differences

• •

Control flow construct variations

• •

Function and variable declaration syntax

• •

Type system differences

• •

Language-specific attributes and annotations

3.3 Intermediate Representation: CrossGL

CrossGL serves as the universal intermediate representation that captures the essential semantics of all supported languages while abstracting away syntactic differences. The design of CrossGL is crucial to the success of our approach.

3.3.1 Type System

CrossGL employs a rich type system that unifies concepts from different programming paradigms:

3.3.2 Language Constructs

CrossGL provides a comprehensive set of language constructs that can express the semantics of all supported source languages:

• •

Expressions: Arithmetic, logical, and comparison operations with explicit type information

• •

Statements: Variable declarations, assignments, control flow (if/else, loops, switch)

• •

Functions: Function definitions with parameter and return type annotations

• •

Data Structures: Struct definitions and member access

• •

Memory Operations: Buffer allocations, pointer arithmetic, and memory access patterns

3.3.3 Attribute System

CrossGL includes a flexible attribute system that preserves language-specific information needed for target code generation:

3.4 Backend: Target Code Generation

The backend stage generates target-specific code from the CrossGL intermediate representation. Each target language has a dedicated code generator that handles language-specific syntax, idioms, and optimization opportunities.

3.4.1 Code Generation Strategy

Our code generators employ a template-based approach with context-sensitive transformations:

Template Matching: CrossGL constructs are matched against target-specific code templates 2. 2.

Context Analysis: The generator analyzes the surrounding context to select appropriate translations 3. 3.

Optimization Integration: Target-specific optimizations are applied during code generation 4. 4.

Validation: Generated code is validated for syntactic and semantic correctness

3.4.2 Backend Architecture Approach

Each backend follows a consistent architecture with specialized components for bidirectional translation:

• •

CUDA Backend: CudaLexer/CudaParser for parsing, CudaCrossGLCodeGen for import, and CudaCodeGen for export, handling kernel launch configurations (<<<>>>), device qualifiers (global, device), and CUDA-specific built-ins

• •

Metal Backend: MetalToCrossGLConverter with comprehensive type mapping (float4→vec4, texture2d→sampler2D) and MetalCodeGen for generating Metal Shading Language with proper buffer bindings

• •

Rust Backend: RustToCrossGLConverter and RustCodeGen producing memory-safe code patterns with appropriate ownership semantics

• •

Vulkan/SPIR-V Backend: VulkanLexer/VulkanParser and VulkanSPIRVCodeGen generating SPIR-V assembly with descriptor set layouts and pipeline state management

4 Implementation

Our implementation of CrossTL consists of modular components organized for maintainability and extensibility. The system is implemented in Python with comprehensive support for 8 fully implemented target languages (CUDA, HIP, Metal, DirectX HLSL, OpenGL GLSL, Vulkan SPIR-V, Rust, Mojo) through a unified architecture, with Slang support in active development. This section describes the key implementation details and design decisions based on the actual codebase.

4.1 Parser Implementation

We implement language-specific parsers using a combination of hand-written recursive descent parsers and parser generator tools. Each parser follows a common interface:

4.1.1 AST Design

Our AST design emphasizes composability and extensibility. Each AST node implements a common interface while allowing for language-specific extensions:

4.2 CrossGL Implementation

The CrossGL intermediate representation is implemented as a set of Python classes with methods for transformation and analysis:

4.2.1 Type System Implementation

The type system is implemented using a visitor pattern that enables extensible type checking and inference:

4.3 Code Generation

Our code generators use a template-based approach with context-sensitive transformations:

4.3.1 Template System

We use a flexible template system that allows for context-dependent code generation:

4.4 Testing Infrastructure

Our testing infrastructure includes comprehensive test suites for each language frontend and backend:

• •

Unit Tests: Test individual components (lexers, parsers, code generators)

• •

Integration Tests: Test end-to-end translation pipelines

• •

Conformance Tests: Verify that generated code produces equivalent results

• •

Extensibility Tests: Measure the framework’s ability to accommodate new languages

We maintain a comprehensive test suite covering various programming constructs and use cases, with each test program verified to compile and execute correctly on all supported target platforms. The implementation includes over 30 test files across 8 fully supported backend directories, with examples ranging from simple 42-line shaders to complex 499-line PBR renderers with Cook-Torrance BRDF, procedural animation, and advanced compute kernels, demonstrating the practical scalability and robustness of the universal translation approach.

5 Evaluation

We evaluate CrossTL across multiple dimensions: translation effectiveness, language coverage, scalability, and extensibility. Our evaluation demonstrates the practical viability of universal code translation across diverse programming domains.

5.1 Test Suite Composition

Our test suite is organized into several categories representing different programming domains and complexity levels, with actual examples from the CrossTL repository:

• •

Basic Graphics: SimpleShader.cgl (42 lines) demonstrating vertex/fragment shader pipeline with basic UV mapping

• •

Advanced Graphics: ComplexShader.cgl (499 lines) featuring Cook-Torrance PBR, procedural animation, shadow mapping, and recursive functions

• •

GPU Computing: MatrixMultiplication.cgl (364 lines) implementing tiled matrix operations with shared memory, vectorization, and warp-level optimizations

• •

Complex Simulations: ParticleSimulation.cgl (287 lines) featuring 4096-particle physics with collision detection, atomic operations, and workgroup collaboration

• •

Cross-Platform Rendering: UniversalPBRShader.cgl (489 lines) implementing full PBR pipeline with IBL, cascaded shadow mapping, and compute-based environment preprocessing

• •

Advanced Features: GenericPatternMatching.cgl and ArrayTest.cgl demonstrating complex control flow, pattern matching, and data structure handling

5.2 Translation Effectiveness

We measure translation effectiveness by verifying that generated code compiles successfully and produces correct results when executed across all supported target languages. Our evaluation demonstrates consistent translation success across all major programming constructs and domains.

Figure 2 shows that our approach achieves universal translation capabilities across all supported target languages, demonstrating the viability of the universal IR design for comprehensive cross-language development.

5.3 Language Coverage Analysis

We analyze the coverage of language features supported by CrossTL across different programming constructs:

5.4 Scalability Analysis

We evaluate the scalability of CrossTL in terms of translation efficiency and the architectural benefits of our universal IR approach.

The linear scaling shown in Figure 4 demonstrates that our approach is practical for real-world applications across various program sizes and all supported languages.

5.5 Universal Translation Quality

We assess the quality of generated code by evaluating the correctness and functionality of CrossTL-generated implementations across all supported languages:

• •

Matrix Operations: All target languages (CUDA, Metal, Rust, etc.) produce functionally equivalent results with proper semantic preservation

• •

Image Processing: Generated shaders across all graphics backends (Metal, DirectX, OpenGL, Vulkan) maintain computational accuracy and visual consistency

• •

Parallel Algorithms: All compute backends (CUDA, HIP, OpenGL compute, etc.) preserve algorithmic correctness and achieve the intended computational results

• •

Complex Compute Shaders: Advanced examples like MatrixMultiplication.cgl (364 lines) with tiled algorithms, shared memory optimization, vectorization, and warp-level primitives successfully translate to all supported platforms

• •

Sophisticated Graphics: ComplexShader.cgl (499 lines) with Cook-Torrance PBR, procedural vertex animation, recursive shadow functions, and advanced material systems maintain correctness across all graphics APIs

• •

Cross-Platform Rendering: UniversalPBRShader.cgl (489 lines) implementing complete PBR pipeline with IBL, cascaded shadows, and compute-based preprocessing demonstrates true cross-platform compatibility

These results demonstrate that CrossTL generates functionally correct code that preserves the intended semantics across all supported target languages.

5.6 Extensibility Evaluation

We evaluate the extensibility of CrossTL by demonstrating the systematic approach for adding support for new languages:

Frontend Implementation: Create lexer and parser following established patterns 2. 2.

AST Translation: Implement AST-to-CrossGL mapping using the universal IR interface 3. 3.

Backend Implementation: Develop code generator using the template-based architecture 4. 4.

Validation Framework: Integrate test cases using the existing testing infrastructure

The modular architecture significantly streamlines the process of adding new languages compared to implementing separate translators for each language pair, demonstrating the practical benefits of our universal IR approach.

5.7 Error Handling and Diagnostics

CrossTL provides comprehensive error reporting throughout the translation pipeline:

• •

Parse Errors: Detailed syntax error messages with source location information

• •

Type Errors: Clear explanations of type mismatches with translation guidance

• •

Translation Warnings: Notifications about language features requiring adaptation

• •

Validation Feedback: Semantic correctness verification for generated code

Our error reporting system provides clear, actionable feedback to developers throughout the translation process across all supported languages.

6 Discussion

6.1 Limitations

While CrossTL demonstrates the viability of universal code translation, several considerations inform future development:

Language Feature Scope: Advanced language-specific features require careful consideration for representation in a universal IR, though the modular architecture accommodates incremental support expansion. 2. 2.

Optimization Opportunities: While generated code maintains semantic correctness, the universal nature of CrossGL provides opportunities for developing sophisticated cross-language optimization strategies. 3. 3.

Semantic Mapping: Language constructs without direct equivalents benefit from the attribute system and backend-specific adaptation strategies to preserve semantic intent. 4. 4.

Domain Coverage: The universal design enables broad applicability while providing extension points for domain-specific optimizations and features.

6.2 Design Trade-offs

Our design makes several important trade-offs that balance universality with practicality:

• •

Universality vs. Specialization: CrossGL is designed for broad compatibility across languages, with extension mechanisms for domain-specific optimizations.

• •

Simplicity vs. Completeness: We prioritize architectural clarity and maintainability while providing extension points for comprehensive feature coverage.

• •

Translation Efficiency vs. Code Optimization: Our focus on efficient universal translation creates opportunities for sophisticated cross-language optimization strategies.

6.3 Comparison with Alternative Approaches

CrossTL offers several advantages over alternative approaches:

• •

vs. Platform Abstraction Layers: CrossTL generates native code for each target language, enabling platform-specific optimizations while maintaining semantic consistency.

• •

vs. Direct Translators: The O(n) scaling of our approach is significantly more manageable than the O(n²) scaling of pairwise translators.

• •

vs. Domain-Specific Solutions: CrossTL supports multiple programming domains through a unified framework, enabling broader applicability and consistent development experience.

6.4 Future Work

Several directions for future work emerge from our experience:

Advanced Language Features: Extending CrossGL to support sophisticated language features like advanced type systems, ownership models, and language-specific optimization attributes. 2. 2.

Cross-Language Optimization: Developing optimization frameworks that leverage the universal IR to apply sophisticated optimizations across all target languages. 3. 3.

Development Tooling: Creating development environments that provide real-time feedback about translation patterns and suggest improvements for cross-language compatibility. 4. 4.

Formal Methods: Developing formal verification techniques for ensuring semantic preservation and correctness across all supported languages. 5. 5.

Intelligent Translation: Exploring machine learning approaches to improve translation patterns and automatically discover optimal cross-language mappings.

7 Conclusion

We have presented CrossTL, a universal programming language translator that enables developers to write code once and deploy across multiple programming languages and platforms. Our approach addresses the scalability challenges of traditional translation methods by introducing a unified intermediate representation that captures the essential semantics of diverse programming languages.

The key innovations of our work include:

A universal intermediate representation (CrossGL) that unifies concepts from GPU computing, graphics programming, and systems languages 2. 2.

A modular architecture that scales linearly with the number of supported languages 3. 3.

Comprehensive framework design demonstrating universal translation viability across multiple programming domains 4. 4.

An extensible framework that enables systematic addition of new languages with minimal implementation effort

Our evaluation demonstrates that CrossTL achieves effective universal translation across diverse programming domains while maintaining consistent semantic preservation and code quality. The system successfully handles complex programming constructs and generates code that compiles and executes correctly across all supported platforms.

CrossTL represents a significant step toward language-agnostic programming, enabling developers to focus on algorithmic logic rather than language-specific implementation details. The universal approach establishes a foundation for sophisticated cross-language development workflows and optimization strategies.

The implications of this work extend beyond immediate practical applications. By demonstrating the feasibility of universal code translation, CrossTL opens new possibilities for cross-platform development, educational tools, and research in programming language design. The modular architecture and universal IR design provide a foundation for future research and development in universal programming language translation.