RTX-STone: Unlock True Blackwell Performance

##UPDATE: 1/5/2026 - To the losers that claim that I am a fraud.

Lets see you run stable UNET3D model training for weeks at 21.8GB on a RTX 5080 16GB card. Most of you losers can't run a video game without overheating. So sit down, shut the hell up and say thank you I am still willing to provide you code. Otherwise get the fuk out of my repo.

🚨 MAJOR DISCOVERY: NVIDIA Driver Gatekeeping Exposed

Your RTX 5080/5090 is being artificially limited - even with PyTorch 2.7+ and CUDA 12.8.

The Problem

Through reverse engineering with Ghidra, we discovered NVIDIA's driver actively rejects native sm_120 (Blackwell) kernel execution and silently falls back to sm_89 (Ada Lovelace) code - causing 30-40% performance loss that users don't even know about.

The Proof

By patching 3 hex bytes in the NVIDIA driver:

3D Graphics Mark: 29,604 → 47,616 (+60.8% improvement!) 🚀
GPU Compute: 23,650 (unlocked performance)
Same hardware, same system - just driver patch
Native sm_120 execution finally working as intended

Read the full analysis: docs/DRIVER_GATEKEEPING_ANALYSIS.md

Native Blackwell (SM 12.0) support + Driver patches for all NVIDIA RTX 50-series GPUs

PyTorch 2.10 with native SM 12.0 compilation + Driver gatekeeping bypass + Triton compiler + Optimization suite for RTX 5090, 5080, 5070 Ti, 5070, and all future RTX 50-series GPUs.

🚀 Quick Start

Option 1: PyPI Installation (Recommended)

# Install RTX-STone from PyPI
pip install rtx-stone[all]

# Verify installation
rtx-stone-verify

# Run benchmarks
rtx-stone-benchmark

Option 2: Manual Installation

# 1. Download and extract the release
# 2. Create virtual environment
python -m venv pytorch-env
.\pytorch-env\Scripts\Activate.ps1

# 3. Run installer (installs PyTorch + optional Triton)
.\install.ps1

# 4. Install additional dependencies (optional but recommended)
pip install -r requirements.txt

# 5. Verify installation
python examples/getting_started.py

# 6. Run benchmarks
python compare_performance.py

Option 3: Driver Patch Only (Advanced)

If you already have PyTorch 2.7+ and just want to unlock true sm_120 performance:

See detailed guide: docs/patch_driver_sm120.md

Quick overview:

Use Ghidra to find 3 sm_120 rejection functions in NVIDIA driver
Patch 3 hex bytes (fail → pass)
Replace system driver with patched version
Enjoy 40% performance boost

Warning: Requires reverse engineering skills, voids warranty, needs driver signature bypass on Windows.

Option 4: Docker

# Pull and run
docker pull rtx-stone:latest
docker run --gpus all -it rtx-stone:latest

# Or build from source
docker build -t rtx-stone:latest .
docker-compose up rtx-stone-jupyter

What you get:

✅ PyTorch 2.10.0a0 with native SM 12.0 (20-30% faster than nightlies)
✅ All RTX 50-series GPUs supported (5090, 5080, 5070 Ti, 5070)
✅ Triton compiler for custom CUDA kernels in Python
✅ Flash Attention 2 (1.5x faster for long sequences)
✅ LLM optimization suite (Llama, Mistral, Qwen support)
✅ HuggingFace integration (one-line model optimization)
✅ Auto-tuning framework (optimal configs for your GPU)
✅ vLLM integration (high-performance serving)
✅ LangChain RAG examples
✅ ComfyUI optimization guide
✅ Multi-GPU support (DDP, FSDP, tensor parallelism)
✅ Docker containers for easy deployment
✅ Jupyter notebooks for tutorials
✅ Production-ready examples and benchmarks
✅ Native Windows (no WSL required!)

Overview

This is a custom-built PyTorch 2.10.0a0 package compiled with native SM 12.0 (Blackwell) support for Windows, PLUS driver-level patches that unlock true Blackwell performance.

The Two-Layer Problem

Layer 1: PyTorch Compilation (SOLVED)

Official PyTorch 2.7+ now compiles sm_120 kernels ✅
Ships CUDA 12.8 binaries ✅

Layer 2: NVIDIA Driver (THIS REPO SOLVES)

Driver actively rejects sm_120 kernels at runtime ❌
Silently falls back to sm_89 (Ada) instead ❌
You lose 30-40% performance without knowing ❌
We reverse-engineered and patched it ✅

Why This Build?

Official PyTorch 2.7 claims:

"Supports NVIDIA Blackwell architecture with CUDA 12.8"

What actually happens:

PyTorch compiles sm_120 kernels ✅
PyTorch loads them successfully ✅
NVIDIA driver rejects them ❌
Driver substitutes sm_89 fallback ❌
User sees "working" but gets ~70% performance ❌

RTX-STone provides:

PyTorch with native sm_120 compilation ✅
Driver analysis and patches to bypass restrictions ✅
True native Blackwell execution ✅
3D Graphics Mark: 47,616 (vs 29,604 stock) ✅
60% better performance than stock driver ✅

This build solves BOTH problems: PyTorch compilation AND driver gatekeeping.

Why Native Windows (Not WSL)?

Performance Advantages:

Direct driver access - No virtualization overhead
Lower latency - No translation layer between Windows and Linux
Better compatibility - Native Windows apps and tools work seamlessly
Simpler workflow - One environment, no dual OS management

WSL2 is great, but native Windows with proper CUDA support is simply faster and more efficient.

🔺 Triton Support - Game Changer for Windows!

This package includes Triton, OpenAI's GPU programming language, with full SM 12.0 Blackwell support on Windows! This is revolutionary for Windows-based RTX 50 series users doing ML research and production work.

What is Triton?

Python-based compiler for writing custom CUDA kernels
No C++/CUDA knowledge required - write GPU kernels in Python!
Automatic optimization for your specific GPU architecture
Used by major ML frameworks (PyTorch, HuggingFace, OpenAI)

Performance Gains on Blackwell (RTX 5080/5090):

1.5x faster Flash Attention (FP16) vs Hopper
2x faster matrix operations with MXFP4 precision
Fused kernels - combine multiple operations to eliminate memory bottlenecks
Native Tensor Core utilization for Blackwell architecture

Use Cases:

Custom model layers and attention mechanisms
High-performance data preprocessing
Research prototyping with production-level performance
Kernel fusion to optimize memory bandwidth

Specifications

PyTorch Version: 2.10.0a0
Triton Version: 3.3+ (triton-windows)
CUDA Version: 13.0
Python Version: 3.10 or 3.11 (recommended)
Platform: Windows 11
Architecture: SM 12.0 (compute_120, code_sm_120)
Package Size: 8.3 GB (uncompressed), 5.3 GB (compressed)

Supported Hardware

All NVIDIA RTX 50-series GPUs with SM 12.0 (Blackwell):

RTX 5090 (24GB VRAM)
RTX 5080 (16GB VRAM)
RTX 5070 Ti (16GB VRAM)
RTX 5070 (12GB VRAM)
All future RTX 50-series GPUs

Requirements

System Requirements

Windows 11 (22H2 or later)
Python 3.10 or 3.11
NVIDIA Driver 570.00 or newer
CUDA 13.0+ compatible driver
15 GB free disk space

Python Dependencies

filelock
fsspec
Jinja2
MarkupSafe
mpmath
networkx
sympy
typing-extensions >= 4.10.0

All dependencies will be installed automatically by the install script.

Installation

Method 1: Automated Installation (Recommended)

# Download the release files
# Extract all parts to the same directory

# Create and activate virtual environment
python -m venv pytorch-env
.\pytorch-env\Scripts\Activate.ps1

# Run the installer
.\install.ps1

The installer will:

Check Python version compatibility (3.10 or 3.11)
Verify CUDA installation and GPU detection
Install required dependencies automatically
Copy PyTorch to your site-packages
Verify PyTorch installation with CUDA
Optionally install Triton (recommended for custom kernels)
Verify Triton JIT compilation (if installed)

Method 2: Manual Installation

# Create virtual environment
python -m venv pytorch-env
.\pytorch-env\Scripts\Activate.ps1

# Install dependencies
pip install filelock fsspec Jinja2 MarkupSafe mpmath networkx sympy "typing_extensions>=4.10.0"

# Extract the torch folder
# Copy to: .\pytorch-env\Lib\site-packages\torch\

Download Instructions

Due to GitHub's file size limits, the package is split into multiple parts:

# Download all parts from GitHub Releases
# pytorch-2.10.0a0-sm120-windows.tar.gz.partaa
# pytorch-2.10.0a0-sm120-windows.tar.gz.partab
# pytorch-2.10.0a0-sm120-windows.tar.gz.partac

# Recombine the parts
cat pytorch-2.10.0a0-sm120-windows.tar.gz.part* > pytorch-2.10.0a0-sm120-windows.tar.gz

# Extract
tar -xzf pytorch-2.10.0a0-sm120-windows.tar.gz

Verification

After installation, verify PyTorch is working correctly:

python

import torch

print(f"PyTorch Version: {torch.__version__}")
print(f"CUDA Available: {torch.cuda.is_available()}")
print(f"CUDA Version: {torch.version.cuda}")
print(f"GPU Name: {torch.cuda.get_device_name(0)}")
print(f"Compute Capability: {torch.cuda.get_device_capability(0)}")
print(f"Arch List: {torch.cuda.get_arch_list()}")

# Test GPU operation
x = torch.rand(5, 3).cuda()
print(f"Tensor device: {x.device}")

Expected output:

PyTorch Version: 2.10.0a0+...
CUDA Available: True
CUDA Version: 13.0
GPU Name: NVIDIA GeForce RTX 5080
Compute Capability: (12, 0)
Arch List: ['sm_120']
Tensor device: cuda:0

Verify Triton Installation

import triton
import triton.language as tl

print(f"Triton Version: {triton.__version__}")

# Test basic JIT compilation
@triton.jit
def add_kernel(x_ptr, y_ptr, output_ptr, n, BLOCK_SIZE: tl.constexpr):
    pid = tl.program_id(axis=0)
    block_start = pid * BLOCK_SIZE
    offsets = block_start + tl.arange(0, BLOCK_SIZE)
    mask = offsets < n
    x = tl.load(x_ptr + offsets, mask=mask)
    y = tl.load(y_ptr + offsets, mask=mask)
    output = x + y
    tl.store(output_ptr + offsets, output, mask=mask)

print("✓ Triton JIT compilation successful")
print("✓ Ready to write custom CUDA kernels in Python!")

Performance

Compared to PyTorch nightlies on RTX 5080:

20-30% faster training and inference
No JIT overhead from PTX compilation
Native Blackwell optimizations for tensor cores and memory bandwidth

Troubleshooting

"CUDA not available" after installation

Verify NVIDIA driver version:
```
nvidia-smi
```
Should show driver >= 570.00
Check CUDA installation:
```
nvcc --version
```

Verify GPU compute capability:

nvidia-smi --query-gpu=compute_cap --format=csv,noheader

Should show 12.0

DLL Load Errors

Ensure you have the latest NVIDIA drivers
Install Visual C++ Redistributable 2015-2022
Check that CUDA 13.0 runtime DLLs are accessible

Python version issues

This build requires Python 3.10 or 3.11. Python 3.12+ may have compatibility issues.

Create a new environment with the correct Python version:

py -3.11 -m venv pytorch-env
.\pytorch-env\Scripts\Activate.ps1

Build Details

This package was compiled from PyTorch main branch with the following configuration:

TORCH_CUDA_ARCH_LIST=12.0
USE_CUDA=1
USE_CUDNN=1
CUDA_HOME=C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA/v13.0

All CUDA kernels were compiled with:

-gencode arch=compute_120,code=sm_120 -DCUDA_HAS_FP16=1 -O2

🚀 Advanced Features

Flash Attention 2

Production-ready Flash Attention implementation optimized for Blackwell:

from flash_attention_rtx5080 import flash_attention

# Drop-in replacement for PyTorch SDPA
output = flash_attention(q, k, v)  # 1.5x faster!

See flash_attention_rtx5080.py for details.

LLM Optimization Suite

Optimized kernels for running Llama, Mistral, and other LLMs:

from llm_inference_optimized import LLMOptimizer

optimizer = LLMOptimizer(model)
optimizer.optimize_attention()  # Flash Attention 2
optimizer.optimize_rope()       # Fused RoPE
optimizer.enable_kv_cache()     # Optimized KV-cache

output = optimizer.generate(input_ids, max_length=100)

Features:

Fused RoPE (Rotary Position Embedding)
Optimized RMSNorm
Efficient KV-cache management
BF16/FP16 mixed precision

HuggingFace Integration

One-line optimization for any HuggingFace model:

from transformers import AutoModelForCausalLM
from huggingface_rtx5080 import optimize_for_rtx5080

model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.2-1B")
model = optimize_for_rtx5080(model)  # That's it!

Automatically applies:

Flash Attention 2
Fused normalization layers
Optimized embeddings
BF16 precision
Gradient checkpointing

Auto-Tuning Framework

Find optimal kernel configurations for your specific GPU:

# Auto-tune all kernels and save config
python autotune_rtx5080.py --save-config

# Auto-tune specific kernel
python autotune_rtx5080.py --kernel matmul

# Load previously saved config
python autotune_rtx5080.py --load-config

The auto-tuner benchmarks different block sizes, warp counts, and memory layouts to find the fastest configuration for your RTX 5080/5090.

Performance Comparison

Compare your build against stock PyTorch and WSL2:

python compare_performance.py --save-results

Benchmarks:

Matrix multiplication (all precisions)
Attention mechanisms (with/without Flash Attention)
Convolution operations
Memory bandwidth

Expected improvements:

20-30% faster than PyTorch nightlies (SM 12.0 vs PTX)
1.5x faster attention with Flash Attention 2
10-15% faster than WSL2 (native Windows advantage)

Benchmarks

PyTorch Benchmark

Test native PyTorch performance with SM 12.0:

python benchmark.py

This benchmarks matrix multiplication at various sizes and precisions (FP32, FP16, BF16).

Triton Benchmark

Test Triton custom kernels optimized for Blackwell:

python benchmark_triton.py

Benchmarks include:

Vector addition
Softmax
Matrix multiplication (GEMM) with Tensor Cores
Performance comparison vs native PyTorch

Triton Examples

Explore production-ready Triton kernel examples:

python triton_examples.py

Examples include:

Fused ReLU + Dropout
Layer Normalization
GELU activation
Fused Linear + Bias + ReLU
Flash Attention (simplified)

📂 Examples

The examples/ directory contains real-world applications:

Getting Started

Verify your installation and run basic tests:

python examples/getting_started.py

This script:

Checks GPU and SM 12.0 support
Tests PyTorch operations
Verifies Triton compilation
Runs quick performance benchmarks
Provides next steps

See examples/README.md for more examples including:

Local Llama chatbot with Flash Attention
Stable Diffusion/FLUX optimization
Custom training loops
Performance comparisons

Getting Started with Triton

Now that you've seen what Triton can do, let's write your first custom kernel!

Your First Triton Kernel

Here's a simple example to get you started:

import torch
import triton
import triton.language as tl

@triton.jit
def vector_add_kernel(x_ptr, y_ptr, output_ptr, n_elements, BLOCK_SIZE: tl.constexpr):
    # Get the program ID (which block we're processing)
    pid = tl.program_id(axis=0)

    # Compute offsets for this block
    block_start = pid * BLOCK_SIZE
    offsets = block_start + tl.arange(0, BLOCK_SIZE)

    # Create a mask for valid elements
    mask = offsets < n_elements

    # Load data from GPU memory
    x = tl.load(x_ptr + offsets, mask=mask)
    y = tl.load(y_ptr + offsets, mask=mask)

    # Perform computation
    output = x + y

    # Store result back to GPU memory
    tl.store(output_ptr + offsets, output, mask=mask)

# Use the kernel
def add(x: torch.Tensor, y: torch.Tensor):
    output = torch.empty_like(x)
    n_elements = output.numel()

    # Launch kernel
    grid = lambda meta: (triton.cdiv(n_elements, meta['BLOCK_SIZE']),)
    vector_add_kernel[grid](x, y, output, n_elements, BLOCK_SIZE=1024)

    return output

# Test it
x = torch.randn(10000, device='cuda')
y = torch.randn(10000, device='cuda')
z = add(x, y)

Learning Resources

Official Triton Tutorials: https://triton-lang.org/main/getting-started/tutorials/
Triton Examples in this repo: triton_examples.py
Benchmarks: benchmark_triton.py
Community: https://github.com/triton-lang/triton/discussions

When to Use Triton

✅ Use Triton when:

You need custom operations not available in PyTorch
Fusing multiple operations to reduce memory bandwidth
Prototyping research ideas with production-level performance
Optimizing specific bottlenecks in your model

❌ Don't use Triton when:

Standard PyTorch operations already meet your needs
You're not familiar with GPU programming concepts yet
The operation is already optimized in cuDNN/cuBLAS

License

PyTorch is released under the BSD-3-Clause license. See the PyTorch repository for details.

This package is compiled from the official PyTorch source code with no modifications except for the architecture target.

Contributing

If you encounter issues or have improvements:

Open an issue describing the problem
Include your GPU model, driver version, and error messages
Provide steps to reproduce

Acknowledgments

PyTorch team for the excellent framework
OpenAI & Triton community for democratizing GPU programming
NVIDIA for the CUDA toolkit and Blackwell architecture
woct0rdho for the triton-windows fork
Community contributors who helped test this build

🐳 Docker Support

RTX-STone is available as Docker containers for easy deployment:

# Development environment
docker-compose up rtx-stone-dev

# Jupyter notebooks
docker-compose up rtx-stone-jupyter
# Access at http://localhost:8888

# vLLM API server
docker-compose up rtx-stone-vllm
# API at http://localhost:8000

# Run benchmarks
docker-compose up rtx-stone-benchmark

See Dockerfile and docker-compose.yml for details.

📚 Jupyter Notebooks

Interactive tutorials in notebooks/:

Getting Started - Installation verification and basic benchmarks
Flash Attention - Optimizing attention mechanisms (coming soon)
Custom Triton Kernels - Writing GPU kernels in Python (coming soon)
LLM Optimization - Optimizing large language models (coming soon)
Image Generation - Stable Diffusion optimization (coming soon)

# Launch Jupyter
jupyter notebook notebooks/

🔌 Integrations

vLLM (LLM Serving)

High-performance LLM inference serving:

# See integrations/vllm_integration.py
python integrations/vllm_integration.py --mode server --model meta-llama/Llama-3.2-3B

LangChain (RAG)

Build RAG systems with local LLMs:

# See integrations/langchain_rag_example.py
python integrations/langchain_rag_example.py --documents ./docs

ComfyUI (Image Generation)

Optimize ComfyUI workflows:

See ComfyUI Integration Guide
20-30% faster image generation
Custom nodes for RTX-STone optimizations

🎯 Model Zoo

Pre-tested configurations and benchmarks:

Model Zoo Documentation
Llama 3.2, 3.1 (3B, 8B, 70B)
Mistral 7B, Mixtral 8x7B
Qwen 2.5
SDXL, SD3, FLUX
Performance benchmarks for each model

🚀 Multi-GPU Support

Distributed training and inference:

# Distributed Data Parallel (DDP)
torchrun --nproc_per_node=2 examples/multi_gpu/distributed_training.py

# FSDP for large models
# See examples/multi_gpu/

# Tensor Parallelism with vLLM
python integrations/vllm_integration.py --tensor-parallel-size 2

📊 Benchmarking Suite

Comprehensive performance testing:

# PyTorch benchmarks
python benchmark.py

# Triton benchmarks
python benchmark_triton.py

# Full comparison vs PyTorch nightlies
python compare_performance.py --save-results

# Or use CLI
rtx-stone-benchmark

🛠️ Command Line Tools

Installed with PyPI package:

# Verify installation
rtx-stone-verify

# Show system info
rtx-stone-info

# Run benchmarks
rtx-stone-benchmark

📖 Documentation

Changelog

v2.10.0a0 + Driver Gatekeeping Discovery (Latest - November 2025)

🔥 BREAKING DISCOVERY: NVIDIA Driver Actively Blocks sm_120 Performance

Reverse-engineered NVIDIA driver with Ghidra
Found 3 functions that reject native sm_120 kernel execution
Created driver patches (3 hex bytes) to bypass restrictions
Validated 60% performance improvement - 3D Graphics Mark: 29,604 → 47,616
GPU Compute subscore: 23,650 (unlocked Blackwell performance)
Documented full methodology for community verification
Exposed silent fallback to sm_89 even with "official" PyTorch 2.7 sm_120 support

NEW Documentation:

docs/DRIVER_GATEKEEPING_ANALYSIS.md - Technical analysis of driver restrictions
docs/DRIVER_PATCH_METHODOLOGY.md - Reverse engineering process
docs/patch_driver_sm120.md - Step-by-step patching guide
docs/REDDIT_RESPONSE.md - Context on PyTorch 2.7 vs driver reality

v2.10.0a0 + Complete Suite

NEW: PyPI package - pip install rtx-stone
NEW: Support for ALL RTX 50-series GPUs (5090, 5080, 5070 Ti, 5070)
NEW: Docker containers with docker-compose
NEW: vLLM integration for LLM serving
NEW: LangChain RAG examples
NEW: ComfyUI optimization guide
NEW: Multi-GPU DDP/FSDP examples
NEW: Jupyter notebooks tutorials
NEW: Model Zoo with benchmarks
NEW: CLI tools (rtx-stone-verify, rtx-stone-benchmark)
NEW: GitHub templates (issues, PRs, contributing)
NEW: CI/CD workflows
NEW: Comprehensive documentation
NEW: Triton compiler integration for Windows
NEW: Native SM 12.0 Blackwell support in Triton kernels
NEW: Flash Attention 2 implementation (flash_attention_rtx5080.py)
- 1.5x faster than PyTorch SDPA on long sequences
- Optimized for Blackwell Tensor Cores
- Drop-in replacement for scaled_dot_product_attention
NEW: LLM Optimization Suite (llm_inference_optimized.py)
- Fused RoPE kernels
- Optimized RMSNorm
- Efficient KV-cache management
- Support for Llama, Mistral, Qwen
NEW: HuggingFace Integration (huggingface_rtx5080.py)
- One-line model optimization
- Automatic Flash Attention injection
- Model-specific optimizations
NEW: Auto-Tuning Framework (autotune_rtx5080.py)
- Find optimal kernel configurations
- Benchmark different block sizes
- Cache tuning results
NEW: Performance Comparison Tool (compare_performance.py)
- Compare vs PyTorch nightlies and WSL2
- Comprehensive benchmark suite
- JSON export for results
NEW: Examples Directory (examples/)
- Getting started script
- Real-world applications
- Best practices guide
NEW: Requirements file (requirements.txt)
- Easy dependency installation
- Optional libraries documented
Triton benchmark suite (benchmark_triton.py)
Production-ready Triton kernel examples (triton_examples.py)
Automated Triton installation in install.ps1
Comprehensive documentation
Learning resources and tutorials

v2.10.0a0 (November 12, 2025)

Initial Windows release
Built from PyTorch main branch
Native SM 12.0 support for RTX 5080
CUDA 13.0 compatibility
Python 3.10/3.11 support

🤝 Contributing

We welcome contributions! See CONTRIBUTING.md for guidelines.

Ways to contribute:

Report bugs and request features
Submit optimized kernels
Share benchmarks and configurations
Improve documentation
Create tutorials and examples

📜 License

BSD-3-Clause (same as PyTorch). See LICENSE for details.

🙏 Acknowledgments

PyTorch team for the excellent framework
OpenAI & Triton community for democratizing GPU programming
NVIDIA for CUDA toolkit and Blackwell architecture
woct0rdho for triton-windows fork
Community contributors who help test and improve

📞 Support

Issues: GitHub Issues
Discussions: GitHub Discussions
Security: See SECURITY.md

⭐ Star History

If this project helped you, consider giving it a star!

RTX-STone - Unleash the full power of your RTX 50-series GPU!

Name		Name	Last commit message	Last commit date
.github		.github
docs		docs
examples		examples
integrations		integrations
notebooks		notebooks
rtx_stone		rtx_stone
.dockerignore		.dockerignore
.gitignore		.gitignore
CODE_OF_CONDUCT.md		CODE_OF_CONDUCT.md
Dockerfile		Dockerfile
LICENSE		LICENSE
MANIFEST.in		MANIFEST.in
README.md		README.md
autotune_rtx5080.py		autotune_rtx5080.py
benchmark.py		benchmark.py
benchmark_triton.py		benchmark_triton.py
compare_performance.py		compare_performance.py
docker-compose.yml		docker-compose.yml
flash_attention_rtx5080.py		flash_attention_rtx5080.py
huggingface_rtx5080.py		huggingface_rtx5080.py
install.ps1		install.ps1
llm_inference_optimized.py		llm_inference_optimized.py
patch_blackwell.diff		patch_blackwell.diff
patch_blackwell.sh		patch_blackwell.sh
patch_config.json		patch_config.json
patch_rtx50_driver.py		patch_rtx50_driver.py
patch_rtx50_simple.py		patch_rtx50_simple.py
pyproject.toml		pyproject.toml
requirements.txt		requirements.txt
setup.py		setup.py
triton_examples.py		triton_examples.py

Latest commit

History

Folders and files

Repository files navigation

RTX-STone: Unlock True Blackwell Performance

🚨 MAJOR DISCOVERY: NVIDIA Driver Gatekeeping Exposed

The Problem

The Proof

🚀 Quick Start

Option 1: PyPI Installation (Recommended)

Option 2: Manual Installation

Option 3: Driver Patch Only (Advanced)

Option 4: Docker

Overview

The Two-Layer Problem

Why This Build?

Why Native Windows (Not WSL)?

🔺 Triton Support - Game Changer for Windows!

Specifications

Supported Hardware

Requirements

System Requirements

Python Dependencies

Installation

Method 1: Automated Installation (Recommended)

Method 2: Manual Installation

Download Instructions

Verification

Verify Triton Installation

Performance

Troubleshooting

"CUDA not available" after installation

DLL Load Errors

Python version issues

Build Details

🚀 Advanced Features

Flash Attention 2

LLM Optimization Suite

HuggingFace Integration

Auto-Tuning Framework

Performance Comparison

Benchmarks

PyTorch Benchmark

Triton Benchmark

Triton Examples

📂 Examples

Getting Started

Getting Started with Triton

Your First Triton Kernel

Learning Resources

When to Use Triton

License

Contributing

Acknowledgments

🐳 Docker Support

📚 Jupyter Notebooks

🔌 Integrations

vLLM (LLM Serving)

LangChain (RAG)

ComfyUI (Image Generation)

🎯 Model Zoo

🚀 Multi-GPU Support

📊 Benchmarking Suite

🛠️ Command Line Tools

📖 Documentation

Changelog

v2.10.0a0 + Driver Gatekeeping Discovery (Latest - November 2025)

v2.10.0a0 + Complete Suite

v2.10.0a0 (November 12, 2025)

🤝 Contributing

📜 License

🙏 Acknowledgments

📞 Support

⭐ Star History

About

Resources

Code of conduct

Contributing

Security policy

Stars