DSL-Guided Transcompilation

• DSL-guided transcompilation is a method that leverages domain-specific language semantics to verify and optimize code translation for hardware efficiency.
• It combines program synthesis, probabilistic grammar learning, and SMT-based verification to ensure semantic equivalence and rapid retargeting.
• The approach reduces engineering effort by using formal IRs and multi-stage, feedback-driven pipelines to drive domain-specific optimizations.

DSL-guided transcompilation is the process of transforming source code—often in a general-purpose or legacy language—into code or intermediate representations in a domain-specific language (DSL), with the DSL providing explicit guidance at all stages of the translation pipeline. The approach leverages the semantic structure and domain knowledge embedded in DSLs to enable verified, performant, and hardware-optimized code generation, while supporting lifting, optimization, and retargeting. Modern DSL-guided transcompilation combines program synthesis, probabilistic grammar learning, symbolic verification, and/or relational programming, achieving correctness and scalability unattainable with conventional syntax-driven or heuristic-based transpilers.

1. DSL Abstractions and Their Role in Transcompilation

DSLs play a central role by encoding the key invariants, operator semantics, and optimization opportunities inherent to a problem domain. In transcompilation pipelines, the DSL’s grammar and operator definitions become the guiding framework for both translation and subsequent code generation.

For machine learning, tensor DSLs (e.g., TACO (Li et al., 28 Apr 2025), DeepDSL (Zhao et al., 2017)) expose tensor contractions, fusion rules, and kernel mappings. For systems targeting specialized hardware, tiny custom DSLs (e.g., the matrix-multiply/convolution DSL for Gemmini accelerators (Nishida et al., 2023), staged host-kernel DSLs for NPU kernels (Wen et al., 30 Jan 2026)) encode hardware-critical configuration and partitioning choices, staging, and memory allocation strategies. In deep learning model rewriting, intermediate DSLs abstract the layer and primitive tensor op sequence of a model, supporting high-fidelity code transformation and kernel integration (Wang et al., 2024).

The explicit structure in the DSL grammar—whether as BNF, probabilistic context-free grammars (pCFGs), or staged IRs—enables both synthesis-based and rule-based approaches to target high-level properties such as shape safety, hardware locality, or operator fusion.

2. Verified Lifting, Synthesis, and Grammar-Guided Approaches

Verified lifting is the paradigm in which code is not only “translated” into a DSL, but the output is proven—constructively or by synthesis—to be functionally equivalent to the input. DSL-guided transcompilation frameworks embody this by integrating the DSL’s semantics at every step of analysis, enumeration, and verification.

Several recent tools operate at this intersection:

• Symbolic Synthesis: Enumerative or SMT-backed search produces candidate DSL programs, tested against the source via symbolic or bounded model checking. Tools such as Metalift for Gemmini (Nishida et al., 2023) formalize the DSL’s semantics in the Metalift IR and automatically generate verification conditions for each candidate, using SMT solvers (e.g., Z3) to formally conclude equivalence.
• LLM-Guided Probabilistic Synthesis: Guided Tensor Lifting (STAGG) (Li et al., 28 Apr 2025) and LLMLift (Bhatia et al., 2024) leverage LLMs to learn probabilistic grammars from a handful of LLM-proposed DSL candidates. The probabilistic grammar is used in weighted A* or similar search, focusing the synthesis engine on high-frequency, domain-relevant patterns. Empirically, STAGG achieves near-complete coverage (99%) and orders-of-magnitude lower synthesis times compared to hand-tuned heuristic systems (Li et al., 28 Apr 2025).
• Relational Compilation: The CoCompiler builds upon relational programming (Walrus), encoding bidirectional relations between source and DSL ASTs (e.g., C↔Lustre) (Spargo et al., 30 Sep 2025). Vertical transcompilation is achieved by defining relations as inference rules, automatically supporting both compilation and lifting with provable semantic preservation.
• Rule-based DSL-Guided Transformations: Adopter (Wang et al., 2024) utilizes a formal DSL for model architecture, expressing transformation rules as source-to-target DSL pattern pairs. Interprocedural CFG analysis and aliasing resolution in Python modules support pattern matching and transformation, mediated entirely in the DSL's formal layer-sequence grammar. Correctness is empirically established via unit-tests and dataflow preservation.

3. Transcompilation Workflows: Multi-Stage and Feedback-Driven Pipelines

Modern DSL-guided transcompilers employ staged, feedback-driven translation workflows in order to achieve robustness and correctness:

• Intermediate Representations (IRs): Most systems construct a typed IR at the DSL level (e.g., ASTs for NMODL (Kumbhar et al., 2019), Metalift IR (Nishida et al., 2023), DeepDSL IR (Zhao et al., 2017)), which is optimized, lowered, and verifiably transformed to target code. This abstraction exposes DSL-level invariants for optimization and formal reasoning.
• Prompting, Synthesis, and Verification Stages: Tools such as LLMLift (Bhatia et al., 2024) and STAGG (Li et al., 28 Apr 2025) use few-shot LLM prompting to generate candidate DSL summaries and invariants, which are then parsed, filtered, and formally verified using automated solvers. The decoupling of candidate generation and proof checking ensures soundness even in the presence of imperfect LLM output.
• Multi-Pass, Constraint-Driven Lowering: In accelerator kernel generation, AscendCraft (Wen et al., 30 Jan 2026) performs staged lowering from a minimal DSL to the target language (AscendC) via four guided passes—host lowering, kernel initialization, compute translation, alignment—each with constraint-driven LLM feedback and verified compilation.
• Empirical, Dataflow, and SMT-Based Correctness Guarantees: Correctness is ensured through combinations of formal proofs (e.g., equivalence with SMT), round-trip testing (as in CoCompiler (Spargo et al., 30 Sep 2025)), and dataflow-conserving transformations (as in Adopter (Wang et al., 2024)).

4. Domain-Specific Optimizations and Hardware Targeting

A major advantage of DSL-guided transcompilation is the ability to drive domain- and hardware-specific optimization passes with explicit DSL structure:

• Automatic Fusion and Algebraic Simplification: High-level DSL abstractions (e.g., TACO, DeepDSL) support systematic operator fusion, symbolic common-subexpression elimination, and compile-time algebraic preprocessing (e.g., analytic ODE solutions using SymPy in NMODL (Kumbhar et al., 2019)).
• Explicit Hardware Mapping: DSLs for hardware accelerators encode mapping parameters as part of their syntax. In the Metalift–Gemmini stack (Nishida et al., 2023), each DSL primitive is a direct proxy for accelerator instructions. AscendCraft (Wen et al., 30 Jan 2026) layers explicit tiling, copyin/compute/copyout ordering, and buffer allocation into the DSL, facilitating correct and high-performing kernel emission.
• Memory Scheduling and Resource Utilization: DSL-level IR and analysis drive static and dynamic memory checks, memory reuse, and live interval scheduling (as in DeepDSL (Zhao et al., 2017)), supporting both correctness and hardware efficiency.
• Backend Retargetability: The preservation of explicit DSL semantics in the IR allows for automated retargeting to new architectures—vector (SIMD/SPMD), multicores, GPUs, or even FPGAs—by overriding backend codegen routines (NMODL (Kumbhar et al., 2019), DeepDSL (Zhao et al., 2017)).

5. Practical Case Studies and Quantitative Impact

Recent evaluations confirm the scale and performance impact of DSL-guided transcompilation:

System	Domain/Target	Success Rate / Speedup	Notes
LLMLift (Bhatia et al., 2024)	MapReduce, Domino, TACO, ML IR	97-100% benchmarks, 1-2 s/benchmark	Outperforms symbolic lifting and hand-tuned heuristics
STAGG (Li et al., 28 Apr 2025)	Tensor (TACO)	99% solved, 3.2 s avg	Probabilistic grammars from LLM => fast, high coverage
Adopter (Wang et al., 2024)	PyTorch→Fused DL kernel	100% precision, 95% recall; 22% speed	Subsequence/scope matching over DSL layer grammar
NMODL (Kumbhar et al., 2019)	NEURON mechanisms→ISPC, CUDA	20× state kernel speedup, 10× full sim	Symbolic, architectural, algebraic optimization
AscendCraft (Wen et al., 30 Jan 2026)	NPU kernels (Ascend)	98% compile, 90% correct, 46% fast as PyTorch	Staged DSL, feedback-driven, category-exemplar LLM

Quantitative impact includes significant reductions in engineering effort (orders of magnitude fewer lines of tool code), lockstep robustness due to formal/empirical verification, and the ability to translate or optimize previously untouchable legacy code.

6. Limitations and Open Challenges

Despite their promise, DSL-guided transcompilers face several challenges:

• LLM Reliability and DSL Learnability: For approaches leveraging LLMs, success depends on the clarity and representativeness of the DSL specification and on the LLM’s capacity for generalization. Exotic or highly-evolving DSLs may require manual intervention or additional few-shot examples (Li et al., 28 Apr 2025).
• Verification Scalability: As program size, nesting, or dynamic features increase, bounded model checking or SMT-based verification may become intractable or imprecise, especially with deep loop nests or floating-point arithmetic (Bhatia et al., 2024).
• Expressivity vs. Tractability: Balancing abstraction (for LLM-guided search and domain transfer) with sufficient hardware- or semantics-critical detail is nontrivial. DSLs that are too abstract obstruct critical optimizations; too concrete overwhelm LLMs and increase synthesis search complexity (Wen et al., 30 Jan 2026).
• Complex Control Flow and Dataflow: Handling nontrivial, data-dependent, or pointer-heavy control flow may require richer grammar constructs, canonicalization passes, or advanced relational reasoning (e.g., semantic-preserving C-canonicalization in CoCompiler (Spargo et al., 30 Sep 2025)).
• Empirical Validation and Continuous Integration: While formal methods guarantee semantic preservation, ultimate real-world performance may demand empirical tuning and feedback-driven refinement, as noted in post-generation re-optimization in AscendCraft (Wen et al., 30 Jan 2026).

7. Generalization Across Domains and Future Directions

The core pattern of DSL-guided transcompilation—extracting the right semantic abstractions, leveraging formal or neural synthesis+verification, and expressing optimization/transformation logic in the DSL—transfers across domains:

• Bidirectionality and Graphical Modeling: Relational compilation supports both compilation and lifting, enabling transformation not only to code but also to graphical behavioral representations (e.g., SCADE (Spargo et al., 30 Sep 2025)).
• Rapid DSL Retargeting: As new DSLs and hardware backends emerge, the same transcompilation architectures, with minimal changes to grammar specifications and examples, yield new verified lifters (Bhatia et al., 2024, Li et al., 28 Apr 2025).
• Hardware-Software Co-design: The integration of cost models, hardware parameter search, and code synthesis (e.g., in future Metalift–Gemmini pipelines (Nishida et al., 2023)) suggests a path toward integrated hardware/software DSL co-optimization.
• Cross-DSL Lifting and Optimization: The abstraction of programs into DSLs at multiple layers (e.g., algorithmic, execution, memory) supports optimization pipelines that span multiple language families and representation layers.

DSL-guided transcompilation thus provides a modular, formally grounded, and increasingly robust methodology for advancing code migration, optimization, and synthesis—a template for future systems across the rapidly changing software and hardware landscape.