Train and run YOLO models in pure C# with TorchSharp.
No Python required — from training to inference, everything stays inside .NET.

• 100% C# implementation – No Python environment, no extra dependencies.
• Full pipeline support – Train, validate, and predict with your own custom models.
• Multiple YOLO versions – Supports YOLOv5, YOLOv5u, YOLOv8, YOLOv11, and YOLOv12.
• All task types – Object detection, segmentation, oriented bounding boxes (OBB), pose estimation (keypoints), and classification.
• Model sizes – n/s/m/l/x variants available for every architecture.
• Advanced preprocessing – Built-in LetterBox and Mosaic4 data augmentation.
• GPU‑accelerated NMS – Non‑maximum suppression runs directly on GPU.
• Pretrained models – Load models from Ultralytics YOLO (v5/v8/v11) and converted YOLOv12 checkpoints.
• Cross‑platform – Works with .NET 6 and later.

• No Python environment – Say goodbye to Conda, pip, dependency hell, and version conflicts. Everything runs inside your existing .NET ecosystem.
• Seamless integration – Directly use C# data structures, LibTorch bindings (TorchSharp),OpenCV bindings (OpenCvSharp), and your .NET logging/tracing infrastructure.
• Simplified deployment – Package your trained model and inference logic into a single .NET application or container. No separate Python microservice needed.
• Performance – Harness GPU acceleration via LibTorch and TorchSharp with full control over memory and execution.
• Productivity – Train and validate models using the same language you use for the rest of your backend, desktop, or game logic. One language, one toolchain.
• Cost‑effective – Reduce operational overhead by eliminating Python runtimes in production.

Whether you're building a desktop application, a cloud service, or an edge device solution, YoloSharp keeps your stack consistent and maintainable.

🚀 Can Load .pt weight now.
🚀 Added Net Standard 2.0 support.
🚀 Added End-to-End (End2End) support for both training and inference.
🚀 Added warm‑up scheduling for stable training start.
🚀 Added rectangle‑resize transform for validation (preserves aspect ratio).
🚀 Added option to disable mosaic augmentation during training.
🚀 Added bias initialization for detection head to improve convergence.
🚀 Replaced CosineAnnealingLR with LambdaLR for more flexible learning rate scheduling.
🐛 Fixed angle loss calculation for oriented bounding boxes (OBB). 🐛 Fixed HSV transform implementation.

2026/10/13
🚀 Can Load .pt weight now.
🐛 Fix the bug of calculating metrics.

2026/06/01
🚀 Added Net Standard 2.0 support.

2026/05/31
🚀 Added End-to-End (End2End) support for both training and inference.
🐛 Fixed angle loss calculation for oriented bounding boxes (OBB).

2026/05/07
🚀 Added data augmentation: horizontal flip, vertical flip, RandomPerspective.
🐛 Fixed Mosaic4 implementation.

2026/03/26
🚀 Added training metrics curves.

2026/03/06
🚀 Configurable training & prediction.
🚀 More metrics for validation.

2026/02/03
🚀 Early stopping.
🚀 HSV transform.
🚀 Training logs.

2026/01/20
🚀 Mixed precision trainer (simple AMP).
🚀 Tqdm support.
🚀 BF16 precision.

Get the official YOLO checkpoints below.

dotnet add package IntptrMax.YoloSharp

string preTrainedModelPath = @"..\..\..\Assets\PreTrainedModels\yolov8n-obb.bin"; // Pretrained model path.
string predictImagePath = @"..\..\..\Assets\TestImage\trucks.jpg";
string dataRootPath = @"..\..\..\Assets\datasets\dotav1";

string trainDataPath = @"train.txt";
string valDataPath = @"val.txt";

Mat predictImage = Cv2.ImRead(predictImagePath);

// Create a Yolo config
Config config = new Config
{
    DeviceType = DeviceType.CUDA,
    ScalarType = ScalarType.BFloat16,
    RootPath = dataRootPath,
    TrainDataPath = trainDataPath,
    ValDataPath = valDataPath,
    YoloType = YoloType.Yolov8,
    YoloSize = YoloSize.n,
    TaskType = TaskType.Obb,
    ImageProcessType = ImageProcessType.Mosiac,
    ImageSize = 640,
    BatchSize = 16,
    NumberClass = 15,
    PredictThreshold = 0.3f,
    IouThreshold = 0.7f,
    Workers = 4,
    Epochs = 100,
    LearningRate = 1e-4f,
    Patience = 50,
    KeyPoint_Num = 21,
    KeyPoint_Dim = 3,
};

// Create a yolo task.
YoloTask yoloTask = new YoloTask(config);

// Load pre-trained model. If you don't want to use pre-trained model, skip the step.
yoloTask.LoadModel(preTrainedModelPath, skipNcNotEqualLayers: true);

// Train model
yoloTask.Train();

// Predict image, if the model is not trained or loaded, it will use random weight to predict.
List<YoloResult> predictResult = yoloTask.ImagePredict(predictImage);

Model	Output
YOLOv8n (detection)
YOLOv8n‑seg
YOLOv8n‑obb
YOLOv8n‑pose

Enjoy YOLO entirely in .NET – no Python needed!
Contributions and feedback are welcome!