Compile Variables

Compile variables are accessible by importing the "builtin" package, which the compiler makes available to every Zig source file. It contains compile-time constants such as the current target, endianness, and release mode.

test.zig

  1. const builtin = @import("builtin");
  2. const separator = if (builtin.os.tag == .windows) '\\' else '/';

Example of what is imported with @import("builtin"):

@import(“builtin”)

  1. const std = @import("std");
  2. /// Zig version. When writing code that supports multiple versions of Zig, prefer
  3. /// feature detection (i.e. with `@hasDecl` or `@hasField`) over version checks.
  4. pub const zig_version = std.SemanticVersion.parse("0.10.1") catch unreachable;
  5. pub const zig_backend = std.builtin.CompilerBackend.stage2_x86_64;
  7. pub const output_mode = std.builtin.OutputMode.Obj;
  8. pub const link_mode = std.builtin.LinkMode.Static;
  9. pub const is_test = false;
  10. pub const single_threaded = false;
  11. pub const abi = std.Target.Abi.gnu;
  12. pub const cpu: std.Target.Cpu = .{
  13.     .arch = .x86_64,
  14.     .model = &std.Target.x86.cpu.znver2,
  15.     .features = std.Target.x86.featureSet(&[_]std.Target.x86.Feature{
  16.         .@"64bit",
  17.         .adx,
  18.         .aes,
  19.         .avx,
  20.         .avx2,
  21.         .bmi,
  22.         .bmi2,
  23.         .branchfusion,
  24.         .clflushopt,
  25.         .clwb,
  26.         .clzero,
  27.         .cmov,
  28.         .crc32,
  29.         .cx16,
  30.         .cx8,
  31.         .f16c,
  32.         .fast_15bytenop,
  33.         .fast_bextr,
  34.         .fast_lzcnt,
  35.         .fast_movbe,
  36.         .fast_scalar_fsqrt,
  37.         .fast_scalar_shift_masks,
  38.         .fast_variable_perlane_shuffle,
  39.         .fast_vector_fsqrt,
  40.         .fma,
  41.         .fsgsbase,
  42.         .fxsr,
  43.         .lzcnt,
  44.         .mmx,
  45.         .movbe,
  46.         .mwaitx,
  47.         .nopl,
  48.         .pclmul,
  49.         .popcnt,
  50.         .prfchw,
  51.         .rdpid,
  52.         .rdpru,
  53.         .rdrnd,
  54.         .rdseed,
  55.         .sahf,
  56.         .sbb_dep_breaking,
  57.         .sha,
  58.         .slow_shld,
  59.         .sse,
  60.         .sse2,
  61.         .sse3,
  62.         .sse4_1,
  63.         .sse4_2,
  64.         .sse4a,
  65.         .ssse3,
  66.         .vzeroupper,
  67.         .wbnoinvd,
  68.         .x87,
  69.         .xsave,
  70.         .xsavec,
  71.         .xsaveopt,
  72.         .xsaves,
  73.     }),
  74. };
  75. pub const os = std.Target.Os{
  76.     .tag = .linux,
  77.     .version_range = .{ .linux = .{
  78.         .range = .{
  79.             .min = .{
  80.                 .major = 5,
  81.                 .minor = 10,
  82.                 .patch = 0,
  83.             },
  84.             .max = .{
  85.                 .major = 5,
  86.                 .minor = 10,
  87.                 .patch = 0,
  88.             },
  89.         },
  90.         .glibc = .{
  91.             .major = 2,
  92.             .minor = 31,
  93.             .patch = 0,
  94.         },
  95.     }},
  96. };
  97. pub const target = std.Target{
  98.     .cpu = cpu,
  99.     .os = os,
  100.     .abi = abi,
  101.     .ofmt = object_format,
  102. };
  103. pub const object_format = std.Target.ObjectFormat.elf;
  104. pub const mode = std.builtin.Mode.Debug;
  105. pub const link_libc = false;
  106. pub const link_libcpp = false;
  107. pub const have_error_return_tracing = true;
  108. pub const valgrind_support = true;
  109. pub const sanitize_thread = false;
  110. pub const position_independent_code = false;
  111. pub const position_independent_executable = false;
  112. pub const strip_debug_info = false;
  113. pub const code_model = std.builtin.CodeModel.default;

See also: