LDC2(1)

📦
version 1.42.0 · 4 versions
, in ubuntu stonking

✨ NAME ✨

Bestie, this is LDC2 — the LLVM D Compiler. Iconic. 👑

💫 DESCRIPTION 💫

🌟 OVERVIEW 🌟

LDC - the LLVM D compiler. No cap, that's the whole vibe.

🚀 USAGE 🚀

ldc2 [options] files --run

So you run ldc2 with some [options] and some files, and if you tack on --run, it runs the resulting program, passing the remaining arguments to it. Slay. 💅

🎀 OPTIONS 🎀

General options:

  • -D — Generate documentation. Cute, right? 📝
  • --Dd=<directory> — Write documentation file to <directory>.
  • --Df=<filename> — Write documentation file to <filename>.
  • -H — Generate 'header' file.
  • --HC — Write C++ 'header' equivalent to stdout.
    • Use -HC=verbose to add comments for ignored declarations (e.g. extern(D)).
  • --HCd=<directory> — Write C++ 'header' file to <directory>.
  • --HCf=<filename> — Write C++ 'header' file to <filename> instead of stdout.
  • --Hd=<directory> — Write 'header' file to <directory>.
  • --Hf=<filename> — Write 'header' file to <filename>.
  • --Hkeep-all-bodies — Keep all function bodies in .di files.
  • -I <directory> — Look for imports also in <directory>.
  • -J <directory> — Look for string imports also in <directory>.

Setting the optimization level:

  • -O — Equivalent to -O3.
  • --O0 — No optimizations (default).
  • --O1 — Simple optimizations.
  • --O2 — Good optimizations.
  • --O3 — Aggressive optimizations.
  • --O4 — Equivalent to -O3.
  • --O5 — Equivalent to -O3.
  • --Os — Like -O2 with extra optimizations for size.
  • --Oz — Like -Os but reduces code size further.
  • -P <cppflag> — Pass <cppflag> to C preprocessor.
  • -X — Generate JSON file.
  • --Xf=<filename> — Write JSON file to <filename>.
  • --allinst — Generate code for all template instantiations.
  • --betterC — Omit generating some runtime information and helper functions.
  • --boundscheck=<value> — Array bounds check.
    • =off — Disabled.
    • =safeonly — Enabled for @safe functions only.
    • =on — Enabled for all functions.
  • -c — Compile only, do not link.
  • --cache=<cache dir> — Enable compilation cache, using <cache dir> to store cache files.
  • --cache-prune — Enable cache pruning.
  • --cache-prune-expiration=<dur> — Sets the pruning expiration time of cache files to <dur> seconds (default: 1 week). Implies -cache-prune.
  • --cache-prune-interval=<dur> — Sets the cache pruning interval to <dur> seconds (default: 20 min). Set to 0 to force pruning. Implies -cache-prune.
  • --cache-prune-maxbytes=<size> — Sets the maximum cache size to <size> bytes. Implies -cache-prune.
  • --cache-prune-maxpercentage=<perc> — Sets the cache size limit to <perc> percent of the available space (default: 75%). Implies -cache-prune.
  • --cache-retrieval=<value> — Set the cache retrieval mechanism (default: copy).
    • =copy — Make a copy of the cache file.
    • =hardlink — Create a hard link to the cache file (recommended).
    • =link — Equal to 'hardlink' on Windows, but 'symlink' on Unix and OS X.
    • =symlink — Create a symbolic link to the cache file.
  • --checkaction=<value> — Action to take when an assert/boundscheck/final-switch fails.
    • =D — Usual D behavior of throwing an AssertError.
    • =C — Call the C runtime library assert failure function.
    • =halt — Halt the program execution (very lightweight).
    • =context — Use D assert with context information (when available).
  • --conf=<filename> — Use configuration file <filename>.
  • --cov — Compile-in code coverage analysis and .lst file generation.
    • Use -cov=<n> for n% minimum required coverage.
    • Use -cov=ctfe to include code executed during CTFE.
  • --cov-increment=<value> — Set the type of coverage line count increment instruction.
    • =default — Use the default (atomic).
    • =atomic — Atomic increment.
    • =non-atomic — Non-atomic increment (not thread safe).
    • =boolean — Don't read, just set counter to 1.
  • --cs-profile-generate — Perform context sensitive PGO instrumentation.
  • --cs-profile-path=<string> — Context sensitive profile file path.
  • --d-debug[=<level/idents>] — Compile in debug code >= <level> or identified by <idents>.
  • --d-version=<level/idents> — Compile in version code >= <level> or identified by <idents>.

Allow deprecated language features and symbols:

  • -d — Silently allow deprecated features and symbols.
  • --dw — Issue a message when deprecated features or symbols are used (default).
  • --de — Issue an error when deprecated features or symbols are used (halt compilation).
  • --deps[=<filename>] — Write module dependencies to <filename> (only imports). '-deps' alone prints module dependencies (imports/file/version/debug/lib).
  • --enable-asserts=<value> — (*) Enable assertions.
  • --enable-color=<value> — (*) Force colored console output.
  • --enable-contracts=<value> — (*) Enable function pre- and post-conditions.
  • --disable-d-passes — Disable all D-specific passes.
  • --disable-gc2stack — Disable promotion of GC allocations to stack memory.
  • --enable-inlining=<value> — (*) Enable function inlining (default in -O2 and higher).
  • --enable-invariants=<value> — (*) Enable invariants.
  • --disable-loop-unrolling — Disable loop unrolling in all relevant passes.
  • --disable-loop-vectorization — Disable the loop vectorization pass.
  • --enable-preconditions=<value> — (*) Enable function preconditions.
  • --disable-red-zone — Do not emit code that uses the red zone.
  • --disable-simplify-drtcalls — Disable simplification of druntime calls.
  • --disable-simplify-libcalls — Disable simplification of well-known C runtime calls.
  • --dllimport=<value> — Windows only: which extern(D) global variables to dllimport implicitly if not defined in a root module.
    • =none — None (default with -link-defaultlib-shared=false).
    • =externalOnly — Only symbols from modules imported from an -extI import root.
    • =defaultLibsOnly — Only druntime/Phobos symbols and symbols from modules imported from an -extI import root (default with -link-defaultlib-shared and -fvisibility=hidden).
    • =all — All (default with -link-defaultlib-shared and -fvisibility=public).
  • --dwarf-version=<int> — Dwarf version.
  • --edition=<NNNN[filename]> — Set language edition to edition year NNNN, optionally only applying to filename.
  • --enable-postconditions=<value> — (*) Enable function postconditions.
  • --enable-switch-errors=<value> — (*) Enable runtime errors for unhandled switch cases.
  • --extI=<directory> — Look also in <directory> for imports that are external to the currently compiling binary. This affects the -dllimport behavior for data symbols from these binary-external modules.
  • --extern-std=<value> — C++ standard for name mangling compatibility.
    • =c++98 — Sets __traits(getTargetInfo, "cppStd") to 199711.
    • =c++11 — Sets __traits(getTargetInfo, "cppStd") to 201103 (default).
    • =c++14 — Sets __traits(getTargetInfo, "cppStd") to 201402.
    • =c++17 — Sets __traits(getTargetInfo, "cppStd") to 201703.
    • =c++20 — Sets __traits(getTargetInfo, "cppStd") to 202002.
    • =c++23 — Sets __traits(getTargetInfo, "cppStd") to 202302.
  • --fcf-protection — Instrument control-flow architecture protection.
  • --fcf-protection=<value> — Instrument control-flow architecture protection.
    • Values: =none, =branch, =return, =full.
  • --fdebug-prefix-map=<<old>=<new>> — Prefix map for filenames in DWARF debuginfo.
  • --fdmd-trace-functions — DMD-style runtime performance profiling of generated code.
  • --ffast-math — Set @fastmath for all functions.
  • --ffat-lto-objects — Include both IR and object code in object file output; only effective when compiling with -flto.
  • --finstrument-functions — Instrument function entry and exit with GCC-compatible profiling calls.
  • --float-abi=<value> — ABI/operations to use for floating-point types:
    • =default — Target default floating-point ABI.
    • =soft — Software floating-point ABI and operations.
    • =softfp — Soft-float ABI, but hardware floating-point instructions.
    • =hard — Hardware floating-point ABI and instructions.
  • --flto=<value> — Set LTO mode, requires linker support.
    • =full — Merges all input into a single module.
    • =thin — Parallel importing and codegen (faster than 'full').
  • --flto-binary=<file> — tell the linker which LTO plugin library to load, bestie. So <file> is something like LLVMgold.so on Unixes or libLTO.dylib on Darwin 🧚
  • --fno-delete-null-pointer-checks — okay so this makes dereferencing a null pointer count as defined behavior while optimizing (instead of undefined behavior, thank u very much). Why does that matter? Because otherwise the optimizer is out here going "well if that pointer got dereferenced it couldn't have been null," and then it optimizes away branches based on that assumption. This flag says not today 💅
  • --fno-discard-value-names — keeps value names in LLVM IR instead of yeeting them into the void.
  • --fno-exceptions — turns off generation of exception stack unwinding code, on the assumption that no Exceptions will be thrown. So like… don't throw 🙈
  • --fno-moduleinfo — stops ModuleInfos from being generated.
  • --fno-plt — don't make function calls through the PLT.
  • --fno-rtti — stops TypeInfos from being generated.
  • --fp-contract=<value> — lets the compiler get aggressive about forming fused FP ops 🔥
    • =fast — fuse FP ops whenever it's profitable
    • =on — only fuse the 'blessed' FP ops.
    • =off — only fuse FP ops when the result won't be affected.
  • --fprofile-generate[=<filename>] — generates instrumented code that collects a runtime profile into default.profraw (which gets overriden by =<filename> or by the LLVM_PROFILE_FILE env var) 📊
  • --fprofile-instr-generate[=<filename>] — same vibe: generates instrumented code to collect a runtime profile into default.profraw, overriden by =<filename> or the LLVM_PROFILE_FILE env var.
  • --fprofile-instr-use=<filename> — uses instrumentation data for profile-guided optimization.
  • --fprofile-sample-use=<filename> — uses instrumentation data for sample-based profile guided optimizations.
  • --fprofile-use=<filename> — uses instrumentation data for profile-guided optimization.
  • --frame-pointer=<value> — picks your frame pointer elimination optimization, choose your fighter:
    • =all — disable frame pointer elimination
    • =non-leaf — disable frame pointer elimination for non-leaf frames
    • =reserved — enable frame pointer elimination, but reserve the frame pointer register
    • =none — enable frame pointer elimination
  • --fsanitize=<checks> — turns on runtime checks for various forms of undefined or suspicious behavior ✨
  • --fsanitize-address-use-after-return=<value> — picks how AddressSanitizer detects stack use-after-return (UAR): never | runtime (default) | always
    • =never — completely disables detection of UAR errors (and reduces code size).
    • =runtime — adds the code for detection, but it can be disabled via the runtime environment (ASAN_OPTIONS=detect_stack_use_after_return=0). Requires druntime support.
    • =always — enables detection of UAR errors in all cases. (reduces code size, but not as much as never). Requires druntime support.
  • --fsanitize-blacklist=<file> — adds <file> to the blacklist files for the sanitizers.
  • --fsanitize-coverage=<type> — says what type of coverage instrumentation you want for -fsanitize.
  • --fsanitize-memory-track-origins=<int> — enables origins tracking in MemorySanitizer (0=disabled, default).
  • --fsanitize-recover=<name> — enables recovery for the specified sanitizers ('all' = enable for all supported sanitizers).
  • --fsave-optimization-record[=<filename>] — generates a YAML optimization record file of all the optimizations LLVM performed 📝
  • --fsplit-stack — uses a segmented stack (see Clang documentation).
  • --fthread-model=<value> — the thread model:
    • =global-dynamic — Global dynamic TLS model (default)
    • =local-dynamic — Local dynamic TLS model
    • =initial-exec — Initial exec TLS model
    • =local-exec — Local exec TLS model
  • --ftime-trace — turns on the time profiler. It generates a JSON file based on the output filename (also see --ftime-trace-file). ⏱️
  • --ftime-trace-file=<filename> — says where the time trace file should go.
  • --ftime-trace-granularity=<uint> — the minimum time granularity (in microseconds) traced by the time profiler.
  • --fvisibility=<value> — the default visibility of symbols:
    • =default — hidden for Windows targets without -shared, otherwise public
    • =hidden — only export symbols marked with 'export'
    • =public — export all symbols
  • --fwarn-stack-size=<threshold> — warns you when the stack size is bigger than the given number.
  • --fxray-instruction-threshold=<value> — sets the minimum function size to instrument with XRay.
  • --fxray-instrument — generates XRay instrumentation sleds on function entry and exit 🛷
  • --gdwarf — emits DWARF debuginfo (instead of CodeView) for MSVC targets.

🐛 Generating debug information 🐛

  • -g — adds symbolic debug info
  • --gc — adds symbolic debug info, and optimizes for non-D debuggers
  • --gline-tables-only — adds line tables only
  • --hash-threshold=<uint> — hashes symbol names longer than this threshold (experimental, bestie 👀).
  • -i[=<pattern>] — includes imported modules in the compilation.
  • --identifiers=<value> — picks the non-ASCII tables used for D identifiers:
    • =c99 — C99
    • =c11 — C11
    • =UAX31 — UAX31
    • =all — All, the least restrictive set, which comes with all the others (default)
  • --identifiers-importc=<value> — picks the non-ASCII tables used for ImportC identifiers:
    • =c99 — C99
    • =c11 — C11 (default)
    • =UAX31 — UAX31
    • =all — All, the least restrictive set, which comes with all the others
  • --ignore — ignores unsupported pragmas (this one's the default, so it's just quietly doing its thing 🌸).
  • --lib — creates a static library.
  • --linkonce-templates — uses discardable linkonce_odr linkage for template symbols, and lazily & recursively defines all referenced instantiated symbols in each object file.
  • --linkonce-templates-aggressive — the experimental, more aggressive variant of the above 👀
  • --lowmem — enables the garbage collector for the LDC front-end. This brings the compiler's memory requirements down but makes compile times go up 📈
  • --lto-aix-system-assembler=<path> — the path to a system assembler, and it's only picked up on AIX.
  • --lto-pass-remarks-filter=<regex> — only records optimization remarks from passes whose names match the given regular expression.
  • --lto-pass-remarks-format=<format> — the format used for serializing remarks (default: YAML).
  • --lto-pass-remarks-output=<filename> — the output filename for pass remarks.
  • --m32 — 32 bit target
  • --m64 — 64 bit target
  • --mabi=<string> — the name of the ABI to be targeted from the backend.
  • --main — adds a default main() if there isn't one already (e.g. for unittesting, cute ✨).
  • --makedeps[=<filename>] — writes module dependencies in Makefile compatible format to <filename>/stdout (only imports).
  • --march=<string> — the architecture to generate code for (see --version).
  • --mattr=<a1,+a2,-a3,...> — target specific attributes (-mattr=help for details).
  • --mcpu=<cpu-name> — targets a specific cpu type (-mcpu=help for details).
  • --mdcompute-file-prefix=<prefix> — a prefix to prepend to the generated kernel files.
  • --mdcompute-targets=<targets> — generates code for the specified DCompute target list. Use 'ocl-xy0' for OpenCL x.y, and 'cuda-xy0' for CUDA CC x.y.
  • --mixin=<filename> — expands and saves mixins to <filename>.
  • --mtriple=<string> — overrides the target triple.
  • --mv=<<package.module>=<filespec>> — uses <filespec> as the source file for <package.module>.
  • --noasm — disallows use of the inline assembler.
  • --nogc — doesn't allow code that generates implicit garbage collector calls.
  • --o- — does not write an object file.
  • --od=<directory> — writes object files to <directory>.
  • --of=<filename> — uses <filename> as the output file name.
  • --op — preserves the source path for output files.
  • --oq — writes object files with fully qualified names.
  • --output-bc — write LLVM bitcode
  • --output-ll — write LLVM IR
  • --output-mlir — write MLIR
  • --output-o — write native object
  • --output-s — write native assembly
  • --plugin=<dynamic_library.so,lib2.so> — passes plugins to load.
  • --preview=<name> — enables an upcoming language change identified by <name>, and honestly just use ? to get the list 🔮
  • --release — compiles a release version, defaulting to disabled asserts/contracts/invariants, and bounds checks in @safe functions only.
  • --relocation-model=<value> — chooses the relocation model:
    • =static — Non-relocatable code
    • =pic — Fully relocatable, position independent code
    • =dynamic-no-pic — Relocatable external references, non-relocatable code
    • =ropi — Code and read-only data relocatable, accessed PC-relative
    • =rwpi — Read-write data relocatable, accessed relative to static base
    • =ropi-rwpi — Combination of ropi and rwpi
  • --revert=<name> — undoes a language change, and <name> tells it which one you mean. don't know the names? pass ? and it'll list them for you. 💅
  • --run <string>... — runs the program you just built, passing whatever else you tacked on along to it. so the leftover args become the program's args, no cap.
  • --shared — creates a shared library (i.e. a DLL). 🎀
  • --singleobj — creates only a single output object file. that's the whole vibe, one object, periodt.
  • --template-depth=<uint> — sets the maximum number of nested template instantiations. keep it cute, don't recurse forever.
  • --threads=<int> — literally no description in the original. it's just standing there. mysterious main character energy 🙈
  • --transition=<name> — helps you out with a language change identified by <name>. again, pass ? for the list. it's like --revert's more supportive cousin.
  • --unittest — compiles in unit tests. 🧪
  • --use-undef — uses undef when generating programs.
  • -v — verbose. tell me everything bestie 🗣️
  • --v-cg — verbose codegen.
  • --vcolumns — prints character (column) numbers in diagnostics.
  • --verror-style=<value> — sets the style for the file/line number annotations on compiler messages. pick your fighter:
    • =digitalmars — 'file(line[,column]): message' — this is the default.
    • =gnu — 'file:line[:column]: message', conforming to the GNU standard used by gcc and clang.
    • =sarif — generates JSON output conforming to the SARIF (Static Analysis Results Interchange Format) standard, useful for integration with tools like GitHub and other SARIF readers.
  • --verror-supplements=<uint> — limits the number of supplemental messages for each error (0 means unlimited — go feral).
  • --verrors=<uint> — limits the number of error/deprecation messages (0 means unlimited).
  • --verrors-context — shows error messages with the context of the erroring source line (including caret). the caret is lowkey iconic.
  • --verrors-spec — shows errors from speculative compiles such as __traits(compiles,...).
  • --vgc — lists all gc allocations, including hidden ones. 👀 nothing escapes.
  • --vtemplates — lists statistics on template instantiations. want more? use -vtemplates=list-instances to additionally show all instantiation contexts for each template.
  • --vv — prints the front-end/glue code debug log.

Warnings: ⚠️

  • -w — enables warnings as errors, meaning compilation will halt. it's giving stern.
  • --wi — enables warnings as messages, so compilation will continue. soft launch energy.

Generic Options: 🛠️

  • --help — displays available options (--help-hidden for more).
  • --help-list — displays a list of available options (--help-list-hidden for more).
  • --version — displays the version of this program.

Linking options: 🔗

  • -L <linkerflag> — passes <linkerflag> to the linker.
  • --Xcc=<ccflag> — passes <ccflag> to GCC/Clang for linking/preprocessing.
  • --defaultlib=<lib1,lib2,...> — the default libraries to link with (overrides previous). note: it overrides, it doesn't append, bestie.
  • --disable-linker-strip-dead — do not try to remove unused symbols during linking.
  • --gcc=<gcc|clang|...> — the C compiler to use for linking (and external assembling). defaults to the CC environment variable if it's set, otherwise to cc.
  • --link-defaultlib-debug — links with debug versions of the default libraries.
  • --link-defaultlib-shared — links with shared versions of the default libraries. defaults to true when generating a shared library (-shared).
  • --linker=<lld-link|lld|gold|bfd|...> — sets the linker to use. when explicitly set to '' (nothing), it prevents LDC from passing -fuse-ld to cc.
  • --mscrtlib=<libcmt[d]|msvcrt[d]> — the MS C runtime library to link with.
  • --platformlib=<lib1,lib2,...> — platform libraries to link with (overrides previous).
  • --static — creates a statically linked binary, including all system dependencies. absolute unit of a binary

Polly Options: Configure the polly loop optimizer 🦜

  • --polly — enables the polly optimizer (works with -O1, -O2 or -O3).
  • --polly-2nd-level-tiling — enables a 2nd level loop of loop tiling. loops on loops, we love to see it.
  • --polly-ast-print-accesses — prints memory access functions.
  • --polly-context=<isl parameter set> — provides additional constraints on the context parameters.
  • --polly-dce-precise-steps=<int> — the number of precise steps between two approximating iterations. (a value of -1 schedules another approximation stage before the actual dead code elimination.) 😵‍💫
  • --polly-delicm-max-ops=<int> — the maximum number of isl operations to invest for lifetime analysis; 0 = no limit.
  • --polly-detect-full-functions — allows the detection of full functions.
  • --polly-enable-simplify — simplifies SCoP after optimizations.
  • --polly-ignore-func=<string> — ignores functions that match a regex. multiple regexes can be comma separated. scop detection will ignore all functions that match ANY of the regexes provided.
  • --polly-isl-arg=<argument> — option passed to ISL.
  • --polly-matmul-opt — performs optimizations of matrix multiplications based on pattern matching.
  • --polly-on-isl-error-abort — abort if an isl error is encountered. no chill mode.
  • --polly-only-func=<string> — only runs on functions that match a regex. multiple regexes can be comma separated. scop detection will run on all functions that match ANY of the regexes provided.
  • --polly-only-region=<identifier> — only runs on certain regions (the provided identifier must appear in the name of the region's entry block).
  • --polly-only-scop-detection — only runs scop detection, but no other optimizations.
  • --polly-optimized-scops — Polly — dumps the polyhedral description of Scops optimized with the isl scheduling optimizer, and the set of post-scheduling transformations is applied on the schedule tree.
  • --polly-parallel — generates thread parallel code (isl codegen only).
  • --polly-parallel-force — forces generation of thread parallel code, ignoring any cost model.
  • --polly-pattern-matching-based-opts — performs optimizations based on pattern matching.
  • --polly-postopts — applies post-rescheduling optimizations such as tiling (requires -polly-reschedule).
  • --polly-pragma-based-opts — applies user-directed transformation from metadata.
  • --polly-pragma-ignore-depcheck — skips the dependency check for pragma-based transformations.
  • --polly-process-unprofitable — processes scops that are unlikely to benefit from Polly optimizations.
  • --polly-register-tiling — enables register tiling.
  • --polly-report — prints information about the activities of Polly. gossip, but for the optimizer.
  • --polly-reschedule — optimizes SCoPs using ISL.
  • --polly-show — highlights the code regions that will be optimized in a (CFG BBs and LLVM-IR instructions).
  • --polly-show-only — highlights the code regions that will be optimized in a (CFG only BBs).
  • --polly-stmt-granularity=<value> — the algorithm to use for splitting basic blocks into multiple statements:
    • =bb — one statement per basic block.
    • =scalar-indep — scalar independence heuristic.
    • =store — store-level granularity.
  • --polly-tc-opt — performs optimizations of tensor contractions based on pattern matching.
  • --polly-tiling — enables loop tiling.
  • --polly-vectorizer=<value> — selects the vectorization strategy:
    • =none — no Vectorization.
    • =stripmine — strip-mine outer loops for the loop-vectorizer to trigger.

okay a couple of housekeeping notes before we move on 👇

-d-debug can also be specified without options, in which case it enables all debug checks (i.e. asserts, boundschecks, contracts and invariants) as well as acting as -d-debug=1.

Boolean options can take an optional value, e.g., -link-defaultlib-shared=<true,false>. Boolean options marked with (*) also have a -disable-FOO variant with inverted meaning.

so, the whole thing is:

based on DMD v2.112.1 and LLVM 19.1.7 built with LDC - the LLVM D compiler (1.42.0) Default target: x86_64-pc-linux-gnu Host CPU: skylake https://dlang.org - https://wiki.dlang.org/LDC

Registered Targets: 🎯

  • aarch64 — AArch64 (little endian)
  • aarch64_32 — AArch64 (little endian ILP32)
  • aarch64_be — AArch64 (big endian)
  • amdgcn — AMD GCN GPUs
  • arm — ARM
  • arm64 — ARM64 (little endian)
  • arm64_32 — ARM64 (little endian ILP32)
  • armeb — ARM (big endian)
  • avr — Atmel AVR Microcontroller
  • bpf — BPF (host endian)
  • bpfeb — BPF (big endian)
  • bpfel — BPF (little endian)
  • hexagon — Hexagon
  • lanai — Lanai

…and the list keeps going, bestie, because there are so many more targets 💅 buckle up:

  • loongarch32 — 32-bit LoongArch
  • loongarch64 — 64-bit LoongArch
  • m68k — Motorola 68000 family
  • mips — MIPS (32-bit big endian)
  • mips64 — MIPS (64-bit big endian)
  • mips64el — MIPS (64-bit little endian)
  • mipsel — MIPS (32-bit little endian)
  • msp430 — MSP430 — [experimental] so don't come for me if it's weird
  • nvptx — NVIDIA PTX 32-bit
  • nvptx64 — NVIDIA PTX 64-bit
  • ppc32 — PowerPC 32
  • ppc32le — PowerPC 32 LE
  • ppc64 — PowerPC 64
  • ppc64le — PowerPC 64 LE
  • r600 — AMD GPUs HD2XXX-HD6XXX
  • riscv32 — 32-bit RISC-V
  • riscv64 — 64-bit RISC-V
  • sparc — Sparc
  • sparcel — Sparc LE
  • sparcv9 — Sparc V9
  • systemz — SystemZ
  • thumb — Thumb
  • thumbeb — Thumb (big endian)
  • ve — VE
  • wasm32 — WebAssembly 32-bit
  • wasm64 — WebAssembly 64-bit
  • x86 — 32-bit X86: Pentium-Pro and above
  • x86-64 — 64-bit X86: EM64T and AMD64
  • xcore — XCore
  • xtensa — Xtensa 32

okay that's it, that's the page, we made it to the end together 🫶 no cap, there is literally nothing else hiding down here. this edition is LDC 1.42.0, dated June 2026 — go compile something iconic with it, you absolute legend 👑✨

📦 where this page comes from