Imagine effortlessly converting code between languages with guaranteed accuracy. That's the promise of verified code transpilation. But traditional methods are complex and often require extensive manual effort. This post explores how Large Language Models (LLMs) are revolutionizing this field, potentially automating the process of creating these powerful transpilers. Traditionally, transpilation involves converting code from a source language to a target language, and verifying its correctness using a process called verified lifting. This process involves defining an intermediate representation (IR) of the target language's operators, translating the source code into this IR, and finally proving the functional equivalence of the translated code and the original source code. This verification step, while crucial for guaranteeing correctness, adds significant complexity to building transpilers. The innovation explored in this research leverages LLMs to simplify this process. By treating Python as an intermediate representation, LLMs can be prompted to translate code into this readily understandable language. This avoids the problem of LLMs struggling with the nuances of lesser-known domain-specific languages (DSLs). Python is also well-represented in the training data of many LLMs, enabling them to translate and reason effectively. The LLM-based approach, known as LLMLIFT, involves two phases: program summary (PS) generation and invariant generation. The PS summarizes the source program using DSL operators within the Python IR. Invariants, which are logical assertions about the program's behavior, help verify the equivalence of the summary and the original code. This approach was tested on four different DSLs: Apache Spark for distributed computing, network packet processing languages, and two tensor processing languages. The findings are remarkable. LLMLIFT not only achieved comparable or better performance in successfully transpiling code than existing symbolic solvers but also did so with dramatically reduced manual effort. It solved more benchmarks faster, and reduced the lines of code required for tool development by a factor of 1000 in some cases. In one case involving tensor processing, LLMLIFT solved all 60 benchmarks compared to 57 solved by a traditional solver, even handling more complex expressions that stumped existing tools. While LLMLIFT represents a considerable advance, challenges remain. LLMs can sometimes generate syntactically or semantically incorrect Python code, requiring a parser to validate the output. Further research is needed to refine the approach for even greater efficiency and reliability. Nonetheless, the implications are exciting. LLMLIFT has the potential to automate the construction of verified transpilers, enabling developers to easily and reliably port code to specialized hardware and benefit from DSL optimizations without arduous manual translation and verification. This could dramatically accelerate the development of high-performance software across many fields.