tree: acadd83aadf808f5b2362b3fbd9b32b35b43c5a4 [search]
  1. test/
  2. .clang-format
  3. jay.h
  4. jay_assign_accumulators.c
  5. jay_builder.h
  6. jay_builder_opcodes.h.py
  7. jay_dag.h
  8. jay_extra_info.h.py
  9. jay_from_nir.c
  10. jay_ir.h
  11. jay_liveness.c
  12. jay_lower_flags.c
  13. jay_lower_helpers.c
  14. jay_lower_post_ra.c
  15. jay_lower_post_sched.c
  16. jay_lower_pre_ra.c
  17. jay_lower_scoreboard.c
  18. jay_lower_send.c
  19. jay_lower_spill.c
  20. jay_nir.c
  21. jay_nir_algebraic.py
  22. jay_opcodes.py
  23. jay_opcodes_gen.py
  24. jay_opt_bfn.c
  25. jay_opt_dead_code.c
  26. jay_opt_postra_vectorize.c
  27. jay_opt_predicate.c
  28. jay_opt_propagate.c
  29. jay_opt_sampler_vectorize.c
  30. jay_partition.c
  31. jay_performance.c
  32. jay_print.c
  33. jay_private.h
  34. jay_prog_data.c
  35. jay_register_allocate.c
  36. jay_schedule.c
  37. jay_simd_width.c
  38. jay_spill.c
  39. jay_stride.c
  40. jay_to_binary.c
  41. jay_validate.c
  42. jay_validate_ra.c
  43. meson.build
  44. README.md
  45. register-file.md
src/intel/compiler/jay/README.md

Jay

Jay is a modern compiler for Intel's Xe GPUs. Jay uses a novel modelling of the Intel register file enabling a straightforward implementation of a decoupled SSA-based register allocator, using a Colombet allocator with a Braun-Hack spiller. As seen at XDC2026 in Toronto.

It currently supports Xe2 (Lunar Lake and Battlemage) and Xe3 (Pantherlake). Additional hardware support is in progress.

Jay is enabled by default on these platforms. For debugging, set INTEL_DEBUG=no-jay to get the old brw compiler.

Contribution policy

We're committed to delivering high-quality software and nurturing healthy software teams. To that end, we have the following guidelines for contributors.

  • Follow the upstream Mesa policy.
  • Submit high-quality patches, regardless of what tools you used.
  • You may use LLMs to improve quality (patch review & static analysis).
  • Please do not use LLMs to try to improve velocity at the expense of quality (no vibecoding).
  • Maintainability matters more than short-term crunch in the long run.
  • People matter more than code.
  • This policy will continue to evolve over time.

Selected background reading:

Advice for debugging

Sometimes, a game will work on our old compiler (brw) but not Jay. In that case, you can follow this checklist to narrow the issue:

Reposting the checklist earlier this summer:

  • does it reproduce locally on Xe2 or Xe3 with upstream Mesa?
  • does it go away if you disable Jay? (INTEL_DEBUG=no-jay env var)
  • does it reproduce in a debug build of Mesa?
  • in a debug build, are there any assertion/validation failures)?
  • ...if so, can you capture a fossil?
  • ...can you reproduce the assertion failure on the fossil?
  • if not, does the issue go away with some combination of Jay debug flags? (JAY_DEBUG=sync,strict,noopt,nosched is a “safe” set).
  • can you bisect it down to a specific shader hash, by selecting between brw and Jay with nir_shader_bisect_select() and the nir_shader_bisect.py script? See the comment in the intel_use_jay() function in src/intel/dev/intel_debug.c for how to enable this.
  • can you dump the affected shader with INTEL_DEBUG=(vs|fs|cs)?
  • can you dump the assembly of that shader with brw?
  • can you diff the before/after assembly to see what Jay is doing different?
  • if the issue goes away with some JAY_DEBUG flag, can you isolate which one?
  • ..and then dump and diff the Jay assembly with/without that flag?

This should get you from “this trace fails” to “this specific shader fails and here's the specific miscompiling assembly to study”. From there, the issue is hopefully easy to spot. If you get stuck there, send those results to a Jay developer for further analysis.