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 == builtin.Os.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.9.0-dev.1966+20328e976") catch unreachable;
  5. /// Temporary until self-hosted is feature complete.
  6. pub const zig_is_stage2 = false;
  7. /// Temporary until self-hosted supports the `cpu.arch` value.
  8. pub const stage2_arch: std.Target.Cpu.Arch = .x86_64;
  9. /// Temporary until self-hosted can call `std.Target.x86.featureSetHas` at comptime.
  10. pub const stage2_x86_cx16 = true;
  12. pub const output_mode = std.builtin.OutputMode.Obj;
  13. pub const link_mode = std.builtin.LinkMode.Static;
  14. pub const is_test = false;
  15. pub const single_threaded = false;
  16. pub const abi = std.Target.Abi.gnu;
  17. pub const cpu: std.Target.Cpu = .{
  18.     .arch = .x86_64,
  19.     .model = &std.Target.x86.cpu.skylake,
  20.     .features = std.Target.x86.featureSet(&[_]std.Target.x86.Feature{
  21.         .@"64bit",
  22.         .adx,
  23.         .aes,
  24.         .avx,
  25.         .avx2,
  26.         .bmi,
  27.         .bmi2,
  28.         .clflushopt,
  29.         .cmov,
  30.         .cx16,
  31.         .cx8,
  32.         .ermsb,
  33.         .f16c,
  34.         .false_deps_popcnt,
  35.         .fast_15bytenop,
  36.         .fast_gather,
  37.         .fast_scalar_fsqrt,
  38.         .fast_shld_rotate,
  39.         .fast_variable_crosslane_shuffle,
  40.         .fast_variable_perlane_shuffle,
  41.         .fast_vector_fsqrt,
  42.         .fma,
  43.         .fsgsbase,
  44.         .fxsr,
  45.         .idivq_to_divl,
  46.         .invpcid,
  47.         .lzcnt,
  48.         .macrofusion,
  49.         .mmx,
  50.         .movbe,
  51.         .nopl,
  52.         .pclmul,
  53.         .popcnt,
  54.         .prfchw,
  55.         .rdrnd,
  56.         .rdseed,
  57.         .sahf,
  58.         .sgx,
  59.         .slow_3ops_lea,
  60.         .sse,
  61.         .sse2,
  62.         .sse3,
  63.         .sse4_1,
  64.         .sse4_2,
  65.         .ssse3,
  66.         .vzeroupper,
  67.         .x87,
  68.         .xsave,
  69.         .xsavec,
  70.         .xsaveopt,
  71.         .xsaves,
  72.     }),
  73. };
  74. pub const os = std.Target.Os{
  75.     .tag = .linux,
  76.     .version_range = .{ .linux = .{
  77.         .range = .{
  78.             .min = .{
  79.                 .major = 5,
  80.                 .minor = 10,
  81.                 .patch = 81,
  82.             },
  83.             .max = .{
  84.                 .major = 5,
  85.                 .minor = 10,
  86.                 .patch = 81,
  87.             },
  88.         },
  89.         .glibc = .{
  90.             .major = 2,
  91.             .minor = 33,
  92.             .patch = 0,
  93.         },
  94.     }},
  95. };
  96. pub const target = std.Target{
  97.     .cpu = cpu,
  98.     .os = os,
  99.     .abi = abi,
  100. };
  101. pub const object_format = std.Target.ObjectFormat.elf;
  102. pub const mode = std.builtin.Mode.Debug;
  103. pub const link_libc = false;
  104. pub const link_libcpp = false;
  105. pub const have_error_return_tracing = true;
  106. pub const valgrind_support = true;
  107. pub const position_independent_code = false;
  108. pub const position_independent_executable = false;
  109. pub const strip_debug_info = false;
  110. pub const code_model = std.builtin.CodeModel.default;

See also: