What does this skill do, and when should you use it?
This skill helps developers convert cuTile Python kernels into cuTile.jl Julia kernels. It addresses differences in syntax, indexing, broadcasting, memory layout, types, and launch APIs, while covering conversion, debugging, testing, and validation. The Julia kernels are standalone and do not use a Python bridge or pytest integration. The documented environment requires a compatible Julia version, CUDA 13.1+ drivers, and a Blackwell GPU.
Analyzes @ct.kernel code, shapes, dtypes, and operations; produces cuTile.jl kernels and bridge functions in julia/kernels/<op>.jl; writes Julia Test cases with NNlib.jl reference results; registers tests; runs scripts/validate_cutile_jl.py for static validation; executes julia --project=julia/ julia/test/runtests.jl; and provides troubleshooting guidance for MethodError, IRError, and numerical mismatches.
- A GPU kernel developer needs to port an existing cuTile Python add, matmul, or softmax kernel to Julia.
- A Julia developer needs to resolve conversion errors involving indexing, row-major versus column-major layout, broadcasting, or ct.load order.
- A team needs Julia-native tests and NNlib.jl reference comparisons for a newly converted cuTile.jl kernel.
- A developer wants to detect common cuTile.jl anti-patterns and launch-argument mistakes before running tests.
- A maintainer needs a documented approach for diagnosing MethodError, IRError, or post-conversion numerical mismatches.
How do you install this skill?
- Do not write project files, install dependencies, or run GPU tests without confirmation; inspect the target and working-tree state first.
- The rm -rf ~/.julia/compiled/cuTile* command is destructive and should be replaced with a recoverable or precisely scoped cleanup requiring confirmation.
- Verify actual compatibility among cuTile.jl, CUDA, Julia, the driver, and a Blackwell GPU; the supplied material does not prove that the Julia translations pass execution tests.
- The benchmark report has an overall FAIL verdict and only one positive task, so broad effectiveness should not be inferred.
- Shell / CLI
- Network access
- Local filesystem
Julia version declared in julia/Project.tomlCUDA 13.1+ driverBlackwell GPU with compute capability 10+CUDA.jlcuTile.jlNNlib.jlTestPython
In an Agent Skills-compatible client, run: npx skills add nvidia/skills --skill tilegym-converting-cutile-to-julia --yes. The README does not specify a fixed installation directory; the CLI handles the destination. Install Julia dependencies with: julia --project=julia/ -e 'using Pkg; Pkg.instantiate()'.
tmp="$(mktemp -d)"
git clone --depth 1 https://github.com/NVIDIA/skills.git "$tmp"
mkdir -p ~/.claude/skills
cp -R "$tmp/skills/tilegym-converting-cutile-to-julia" ~/.claude/skills/
rm -rf "$tmp"Generated from the source repository and skill path; it copies only this skill's folder. If the author's install steps above differ, follow those first. To scope it to one project, replace ~/.claude/skills with that project's .claude/skills.
How do you use this skill?
Once installed, send your agent any of these to trigger it:
- Convert this @ct.kernel cuTile Python GPU kernel to a cuTile.jl Julia kernel, then validate and test it using the skill workflow.
Ask the agent something like: “Convert this @ct.kernel cuTile Python GPU kernel to a cuTile.jl Julia kernel, then validate and test it using the skill workflow.” The documented process analyzes the kernel, writes julia/kernels/<op>.jl, creates and registers julia/test/test_<op>.jl, runs python <skill-dir>/scripts/validate_cutile_jl.py <file.jl>, and runs julia --project=julia/ julia/test/runtests.jl.
What are this skill's strengths and limitations?
- Focused specifically on the semantic differences between cuTile Python and cuTile.jl.
- Includes add, matmul, and softmax examples plus ground-truth Julia kernels and tests.
- Provides 17 critical rules, API mappings, debugging guidance, and testing references.
- Includes a static validator and a complete Julia-native testing workflow.
- It targets cuTile Python-to-Julia conversion rather than general Python-to-Julia translation.
- It requires a compatible Julia version, CUDA 13.1+ drivers, and a Blackwell GPU.
- The source does not document support for other GPU architectures or older CUDA drivers.
- The repository metadata says NOASSERTION for the license, while the skill declares CC-BY-4.0 AND Apache-2.0; licensing should be checked before adoption.
How does this skill compare with similar options?
Side by side with related skills; every score comes from the same FSRS standard.
| Skill | FS score | Stars | Last updated | License |
|---|---|---|---|---|
| cuTile Python-to-Julia Converter this page ✓ NVIDIA · Official | 47 · Use with care | ★ 3.8k | today | Apache-2.0 |
| cuTile-to-Triton Kernel Converter ✓ NVIDIA · Official | 38 · Not recommended | ★ 3.8k | today | Apache-2.0 |
| CuTile Autotuning Guide ✓ NVIDIA · Official | 52 · Use with care | ★ 3.8k | today | Apache-2.0 |
| cuTile Python Kernel Assistant ✓ NVIDIA · Official | 44 · Not recommended | ★ 3.8k | today | Apache-2.0 |
| TileGym cuTile Kernel Optimizer ✓ NVIDIA · Official | 44 · Not recommended | ★ 3.8k | today | Apache-2.0 |
How did FollowSkills review this skill?
The scope is clear and focuses on local kernel edits, dependency setup, and testing; no malware, credential theft, or covert exfiltration is shown. Points are deducted because the workflow proceeds to file writes, dependency installation, and test execution without user confirmation, the debugging guide includes an rm -rf cache command, rollback and data-flow disclosures are absent, and dependency security is not addressed.
The documentation supplies conversion steps, error patterns, examples, and test commands, and advises filing minimal reproducers for internal compiler errors. Static evidence is limited: the selected path does not include the claimed Julia kernels, test suite, or CI evidence; the benchmark report says the overall evaluation failed and notes duplication and unverified assumptions. The score is therefore kept below the static ceiling.
The intended users, input type, and main conversion scenarios are clear, including conversion, debugging, and optimization, with hardware and version prerequisites listed. Points are deducted because non-fit boundaries, exclusion triggers, Chinese-language support, and mainland-China reachability are not specified; requiring a local Blackwell GPU narrows the environment substantially.
The workflow, API mapping, critical rules, testing, and debugging documents provide a reasonably layered structure. The skill declares CC-BY-4.0 AND Apache-2.0, an author, and tags, while the repository provides license and official-organization attribution. Points are deducted for missing explicit versioning, changelog, maintenance responsibility, and update path; the benchmark also reports duplicated content, a missing recommended Examples section, missing script-table documentation, and deep references.
The skill presents an end-to-end process from analysis through implementation, testing, and validation, with add, matmul, and softmax examples that could reduce manual migration effort. Points are deducted because this review is static, the canonical Julia kernels, tests, and validator implementation are not included in the supplied evidence, and the benchmark's overall verdict is FAIL, so directly usable output is unverified.
The material includes auditable rules, commands, example verification code, and a benchmark report. Points are deducted because no committed Julia test results, CI logs, or independently reproducible execution evidence are supplied; the benchmark gives only aggregate metrics and an overall FAIL verdict, providing limited static verification.
Open a dimension to read why it scored that way
Evidence confidence：Low — Mostly static review, author material or a limited demo; useful for discovery, not high-risk decisions.
See the full review method →