Understanding Targets¶
TileLang is built on top of TVM, which relies on targets to describe the device you want to compile for. The target determines which code generator is used (CUDA, HIP, Metal, LLVM, …) and allows you to pass device-specific options such as GPU architecture flags. This page summarises how to pick and customise a target when compiling TileLang programs.
Common targets¶
TileLang ships with a small set of common target kinds. Use a bare string for the kind, or a TVM target config dictionary when you need options such as GPU architecture or CPU model. The most frequent choices are listed below:
Base name |
Description |
|---|---|
|
Detects CUDA → HIP → Metal in that order. Useful when running the same script across machines. |
|
NVIDIA GPUs. Use a config dict for options such as |
|
NVIDIA CUTLASS/CuTe DSL backend. Requires |
|
AMD GPUs via ROCm. Use a config dict for options such as |
|
Apple Silicon GPUs (arm64 Macs). |
|
CPU execution. Use a config dict for options such as |
|
Browser / WebGPU runtimes. |
|
Emit plain C source for inspection or custom toolchains. |
To add options, pass a target config dictionary. For example:
target = {"kind": "cuda", "arch": "sm_90"}
kernel = tilelang.compile(func, target=target, execution_backend="cython")
# or
@tilelang.jit(target=target)
def compiled_kernel(*args):
return func(*args)
Advanced: Specify Exact Hardware¶
When you already know the precise GPU model, you can encode it in the target config via arch="sm_XX" or by
using one of TVM’s pre-defined target tags such as nvidia/nvidia-h100. Supplying this detail is optional for
TileLang in general use, but it becomes valuable when the TVM cost model is enabled (e.g. during autotuning). The
cost model uses the extra attributes to make better scheduling predictions. If you skip this step (or do not use the
cost model), generic targets like cuda or auto are perfectly fine.
All CUDA compute capabilities recognised by TVM’s target registry are listed below. Pick the one that matches your
GPU and set it in the target config or use the corresponding target tag—for example nvidia/nvidia-a100.
Architecture |
GPUs (examples) |
|---|---|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Refer to NVIDIA’s CUDA GPUs page or the TVM source
(3rdparty/tvm/src/target/tag.cc) for the latest mapping between devices and compute capabilities.
Creating targets programmatically¶
TileLang exposes the helper tilelang.backend.target.determine_target (returns a canonical target string or config
by default, or the Target object when return_object=True):
from tilelang.backend.target import determine_target
tvm_target = determine_target({"kind": "cuda", "arch": "sm_80"}, return_object=True)
kernel = tilelang.compile(func, target=tvm_target)
You can also build targets directly through TVM:
from tvm.target import Target
target = Target("cuda", host="llvm")
target = target.with_host(Target({"kind": "llvm", "mcpu": "skylake"}))
TileLang accepts bare target strings, target config dictionaries, and Target inputs. For targets with options,
prefer config dictionaries over CLI-style strings.
Troubleshooting tips¶
If you see
Target {'kind': 'cuda', 'arch': 'sm_80'} is not supported, double-check the spellings and that the option is valid for TVM. Any invalid option will surface as a target-construction error.Runtime errors such as “no kernel image is available” usually mean the
archvalue does not match the GPU you are running on. Try dropping the flag or switching to the correct compute capability.When targeting multiple environments, use
autofor convenience and override with an explicit config only when you need architecture-specific tuning.