Here is the usage, which shows how many backends this supports (pretty impressive IMO). USAGE: waxc options code.wax OPTIONS: -c path/out.c transpile to c -java path/out.java transpile to java -ts path/out.ts transpile to typescript -py path/out.py transpile to python -cs path/out.cs transpile to c# -cpp path/out.cpp transpile to c -swift path/out.swift transpile to swift -lua path. GDScript evolved as a custom scripting language to be used with the Godot computer (and mobile device) game engine, and for those people who look beyond the real world, it also supports Virtual Reality. You can start your new exciting journey of discovery today by checking out the GDScript Tutorials. It is often said that an old dog. Cmake -HstandaloneLua -Bbuild/lua # Compiles C code. CMake will use the latter to ensure that the declarations at typescript/cpplib.d.ts are up-to-date and then transpile the TypeScript code to Lua or JavaScript. Type-safe scripting for C using TypeScript and CMake with auto-generated declarations. Lua is famously and deceptively simple and enables many different programming paradigms. Like Javascript, it's possible to make it shine by adding more specialized syntax. I started this list to document the languages I found looking for an ML/F# like language. Universal-transpiler is a source-to-source compiler that translates a small subset of several programming languages into several others. It is also able to translate several metasyntax notations, such as EBNF and ABNF. Universal-transpiler was written as an experimental “proof-of-concept,” so it can only translate relatively simple programs.

The C2Rust project is all about translating Ccode into an equivalent, drop-in ABI-compatible Rust implementation. (Read ourC2Rust introductory blog post here.)Along the way we’ve uncovered some dark corners of C as it’s written in practice, andfound places where Rust can’t quite replicate the same code with the same ABI. This isthe story of those dark corners and the areas we think Rust needs to improve to be fullyFFI compatible with C.

Background

Rust was designed as a systems programming language that enforcestemporal memory safety at compile-time, via a borrow checker that enforces strictownership rules and limits aliasing for memory allocations and pointers.Additionally, Rust automates memory management using the RAIIpattern, which is also enforced at compile-time by calling local objects'destructors at the end of each scope. Conversely, other programming languagessolve these problems using garbage collection or reference counting. However, the garbage collectoris usually a significant part of the language runtime and its existenceinfluences the design of the rest of the language, including the language’s FFI. Passing GC’ed objects through the FFI to another language, e.g., C,poses significant challenges since the GC must track pointers across languagesor risk freeing them prematurely; alternatively, the GC’ed language maydisallow passing GC’ed pointers through the FFI completely, like in Go,or shift the burden of memory allocation back to the developer.

Rust’s static enforcement of memory safety (as opposed to dynamic management via garbage collection or reference counting) positions it as a valuable alternative to C or C++ in a lot of use cases. These include situations where:

multiple languages must coexist in a process and communicate over a FFI,
adding a heavyweight language runtime is infeasible, and
the pause times or memory requirements of garbage collection are undesirable.

Rust is one of the few languagesthat can be used to implement middleware and OS components, with the rewrites optionally beingdrop-in replacements for the originals. In fact, one of themost frequent questions we get when discussing C2Rust with others is“Have you tried transpiling OpenSSL?” (fortunately, there already exists abinary-compatible rewrite written in Rust).Another good Rust drop-in replacement example is therelibc library, which is a C standardlibrary written in Rust. While Rust can compete with languages like Java, Go,Swift, and Python at writing applications, it is particularly suited for writing librariesand low-level system components, e.g.,kernel modules andfirmware.

In cases like the above, binaries compiled from Rust are not used in astandalone environment, but linked (either statically or dynamically) as acomponent of a larger system, which may be written in one or several otherlanguages, e.g., C. This means that the Rust binaries must be ABI-compatiblewith the C binaries. On Linux, such binaries are compiled with gcc or clang,and linked using the GNU linker, gold or lld. To achieve true ABI parity withgcc, rustc should ideally support every gcc extension to C.In his presentation on Rust andsystems programming earlier this year, Josh Triplett named paritywith C as a significant factor in systems language adoption, and concluded witha list of current problems and future improvements on this front.In this blog post, we give some real-world examples where Rust is not yetfully compatible with C, some of which already mentioned by Josh in his talk.

Opportunities to improve Rust’s compatibility with C

While converting C code to Rust using C2Rust, we encounteredsome edge cases where Rust cannot quite replicate C features (or at least gcc’s variant of C).If we want Rust to be an ABI-compatible replacement for C, these are a fewof the issues that we need to resolve.

`long double` types

long double types in C are specified as being at least as long as double but aregenerally implemented as 80-bit floating point values on x86, although implementations areplatform-dependent. To be fully ABI-compatible with C code, Rust needs to support longflointing-point types that match the implementations used on supported platforms, i.e.,f80 and f128. A Pre-RFC thread was started to discuss alternative floating-point types. Addingthese types under std::arch was suggested, which seems like a good path forward.

We ran into long double types in the wild when trying to translate the newlib C library,which can optionally be built with support for the long double type, including in its printf implementation. The best available alternative forlong floating-point types is the f128 crate, which internally implementsit as an array of bytesand implements all operations inC.However, since long double in most x86 C compilers is an 80-bit floating pointinternally stored in 128 bits, it is not ABI-compatible with the __float128 typeimplemented by the f128 crate. This poses problems not only for long double usein variadics (which is how we initiallyencountered this problem), butalso when passing long double values between C and Rust.

GCC extensions

Many gcc extensions to C do not have Rust equivalents. For example, we raninto issues with the following extensions:

Symbol aliases (link to open issue),i.e., __attribute__((alias('foo'))), used bylibxml2.This attribute exports the same function or global variable as multiple symbols (whichmay even have different visibilities). Rust provides #[no_mangle] and#[link_name='..'] which let us rename a global, but no equivalent attributeto export it under a second name.
Packed structures that also have alignment requirements, e.g.,xregs_state from the kernel.We opened an issue on this on GitHub,and the discussion is still ongoing.
Aligned globals, e.g., ssemask from ioq3.We could handle these cases by replacing them with aligned structures, but thatwould not be perfectly equivalent with the original C code. For example, forthis C code:

the alignments of variables foo and foo16 are both 16, but their sizes are5 and 16 respectively.

Static library sizes

Most of the time we want to build a C shared library (cdylib) when building drop-inreplacement Rust code. However, when we want to build a static library, the resulting libraryis huge. For example, building the minimal no_std rust module below, which doesn’t dependon any of the Rust standard library, results in a 1.6M static library!

results in the following crate file sizes:

Crate type	Size
`staticlib`	1.6M
`rlib`	5K
`cdylib`	15K

Because we needed to embed this code inside a kernel module, we couldn’t use cdylib(kernel modules are .ko files which are obj

Background

Opportunities to improve Rust’s compatibility with C

long double types

GCC extensions

Static library sizes

`long double` types

Lua Transpile C++