ಸ್ಥಳೀಯ ದೊಡ್ಡ ಭಾಷಾ ಮಾದರಿಗಳನ್ನು (large language models) ಚಲಾಯಿಸುವುದು ಹೆಚ್ಚಾಗಿ ನಿಮ್ಮನ್ನು ಹಾರ್ಡ್‌ವೇರ್ ಮಿತಿಯೊಳಗೆ ಸಿಲುಕಿಸುತ್ತದೆ. NVIDIA ಬಳಕೆದಾರರು CUDA ಪರಿಸರ ವ್ಯವಸ್ಥೆಯೊಳಗೆ ಇರುತ್ತಾರೆ. Apple ಡೆವಲಪರ್‌ಗಳು Metal ಅನ್ನು ಬಳಸುತ್ತಾರೆ. ಉಳಿದವರೆಲ್ಲರೂ ತಮ್ಮ GPU, OpenCL ಅನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ ಎಂದು ಭಾವಿಸುತ್ತಾರೆ ಅಥವಾ ಕೇವಲ CPU ಅನ್ನು ಅವಲಂಬಿಸುತ್ತಾರೆ. ಈ ವಿಭಜನೆಯು (fragmentation) ಡೆಸ್ಕ್‌ಟಾಪ್ AI ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಬಿಡುಗಡೆ ಮಾಡುವುದನ್ನು ಅನಿವಾರ್ಯತೆಗಿಂತ ಹೆಚ್ಚು ಕಷ್ಟಕರವಾಗಿಸುತ್ತದೆ. TensorSharp ಈಗ Vulkan backend ಅನ್ನು ಸೇರಿಸುವ ಮೂಲಕ ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ಮುಂದಾಗಿದೆ, ಇದು ವಿವಿಧ ಮಾರಾಟಗಾರರ (vendors) discrete GPUs ಮೂಲಕ ಇಂಜಿನ್‌ಗೆ ಒಂದು ವಿಶ್ವಾಸಾರ್ಹ ಮಾರ್ಗವನ್ನು ನೀಡುತ್ತದೆ.

Vulkan ಏಕೆ ಈ ಪರಿಸ್ಥಿತಿಯನ್ನು ಬದಲಾಯಿಸುತ್ತದೆ

Vulkan ಅನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಗೇಮಿಂಗ್ ವಲಯಗಳಲ್ಲಿ ಚರ್ಚಿಸಲಾಗುತ್ತದೆ, ಆದರೆ ಕಡಿಮೆ ಓವರ್‌ಹೆಡ್ ಹೊಂದಿರುವ, ಕ್ರಾಸ್-ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಕಂಪ್ಯೂಟ್ API ಆಗಿ, ಇದು ಇನ್ಫರೆನ್ಸ್ (inference) ಗೂ ಅಷ್ಟೇ ಮುಖ್ಯವಾಗಿದೆ. ಇದು CUDA ನಿರ್ಲಕ್ಷಿಸುವ ಹಾರ್ಡ್‌ವೇರ್‌ಗಳಿಗೂ ತಲುಪುತ್ತದೆ. Intel UHD ಮತ್ತು Iris Xe ಇಂಟಿಗ್ರೇಟೆಡ್ ಚಿಪ್‌ಗಳು, ಹಳೆಯ discrete ಕಾರ್ಡ್‌ಗಳು ಮತ್ತು NVIDIA ಸ್ಟಿಕ್ಕರ್ ಇಲ್ಲದ ಬಜೆಟ್ Windows ಲ್ಯಾಪ್‌ಟಾಪ್‌ಗಳು ಇದಕ್ಕೆ ಸೇರಿವೆ. ಸ್ಥಳೀಯ ಇನ್ಫರೆನ್ಸ್ ಇಂಜಿನ್‌ಗೆ, ಈ ವ್ಯಾಪ್ತಿಯು ಪ್ರಾಯೋಗಿಕ ಶಕ್ತಿಯಾಗಿದೆ. ಒಬ್ಬ ಡೆವಲಪರ್ ಕೇವಲ CUDA-ಮಾತ್ರದ ಪರಿಹಾರಕ್ಕಿಂತ ಹೆಚ್ಚಿನ ಯಂತ್ರಗಳಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವಂತಹ ಏಕೈಕ ಬೈನರಿ ಪಾತ್ ಅನ್ನು ಬಿಡುಗಡೆ ಮಾಡಬಹುದು.

TensorSharp ನ Vulkan ಬೆಂಬಲವು GGML ಪ್ರಾಜೆಕ್ಟ್ ಮೂಲಕ ಪ್ರಾರಂಭವಾಯಿತು. ಈ ಇಂಟಿಗ್ರೇಶನ್ ಇಂದು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದೆ, ಆದರೂ ಲೇಖಕರು ನಂತರ ಒಂದು native Vulkan backend ಅನ್ನು ನಿರ್ಮಿಸಲು ಯೋಜಿಸಿದ್ದಾರೆ. GGML ಅನ್ನು ಸೇತುವೆಯಾಗಿ ಬಳಸುವುದು ಸರಿಯಾದ ಹಂತದ ನಿರ್ಧಾರವಾಗಿತ್ತು. ಇದು ಆರ್ಕಿಟೆಕ್ಚರ್ ಅನ್ನು ದೃಢೀಕರಿಸುತ್ತದೆ ಮತ್ತು ತಕ್ಷಣವೇ ಹಾರ್ಡ್‌ವೇರ್ ಅನ್ನು ಟೆಸ್ಟರ್‌ಗಳ ಕೈಗೆ ತಲುಪಿಸುತ್ತದೆ. ಅಬ್‌ಸ್ಟ್ರಾಕ್ಷನ್ ಓವರ್‌ಹೆಡ್ ಅನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಮತ್ತು C#-ಕೇಂದ್ರಿತ ಇಂಜಿನ್‌ಗೆ command buffers ಮತ್ತು memory barriers ಮೇಲೆ ಹೆಚ್ಚಿನ ನಿಯಂತ್ರಣ ನೀಡಲು native backend ನಂತರ ಬರಲಿದೆ.

ಇದುವರೆಗೆ ಪರೀಕ್ಷಾ ವಲಯ ಹೇಗಿದೆ?

ದೃಢೀಕರಣವು ಈಗಾಗಲೇ ಎರಡು ವಿಭಿನ್ನ Windows ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿದೆ. ಡೆವಲಪರ್ NVIDIA GeForce RTX 3080 Laptop GPU ಮತ್ತು ಸಾಮಾನ್ಯ Intel UHD Graphics ಮೇಲೆ ಪರೀಕ್ಷೆ ಮಾಡಿದರು. ಎರಡೂ ಚೆನ್ನಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸಿದವು. ಈ ವ್ಯಾಪ್ತಿಯನ್ನು ಗಮನಿಸುವುದು ಮುಖ್ಯವಾಗಿದೆ. ಇನ್ಫರೆನ್ಸ್ ಜಗತ್ತಿನಲ್ಲಿ, discrete high-wattage silicon ಮತ್ತು ಮೂಲಭೂತ ಇಂಟಿಗ್ರೇಟೆಡ್ ಗ್ರಾಫಿಕ್ಸ್ ಇಷ್ಟು ಸುಲಭವಾಗಿ ಒಂದೇ ಪರೀಕ್ಷಾ ವಲಯವನ್ನು ಹಂಚಿಕೊಳ್ಳುವುದು ಅಪರೂಪ. ನೀವು ಪ್ರತ್ಯೇಕ GPU ಇಲ್ಲದ ಲಘು (lightweight) ಲ್ಯಾಪ್‌ಟಾಪ್ ಬಳಸುತ್ತಿದ್ದರೆ, TensorSharp ಈಗ NVIDIA ಡ್ರೈವರ್‌ಗಳ ಮೇಲೆ ಅವಲಂಬಿತವಾಗದ ನೈಜ ವೇಗವರ್ಧನೆಯ (acceleration) ಮಾರ್ಗವನ್ನು ನೀಡುತ್ತದೆ.

ಈ ವ್ಯವಸ್ಥೆಯಲ್ಲಿನ ಕೊರತೆಯೆಂದರೆ AMD. ಯಾವುದೇ Radeon ಹಾರ್ಡ್‌ವೇರ್ ಅನ್ನು ಇದುವರೆಗೆ ಪರೀಕ್ಷಿಸಲಾಗಿಲ್ಲ. ನೀವು AMD GPU ಹೊಂದಿದ್ದರೆ, ಈ ಪ್ರಾಜೆಕ್ಟ್‌ಗೆ ನಿಮ್ಮ ಪ್ರತಿಕ್ರಿಯೆಯ ಅಗತ್ಯವಿದೆ. RX 6000 ಅಥವಾ 7000 ಸರಣಿ ಕಾರ್ಡ್‌ಗಳ ಮೇಲೆ ಸಮುದಾಯದ ದೃಢೀಕರಣವು ಒಂದು ಪ್ರಾಯೋಗಿಕ backend ಅನ್ನು ಪ್ರೊಡಕ್ಷನ್-ಗ್ರೇಡ್ ಆಯ್ಕೆಯನ್ನಾಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ. ಇದು ಕೆಲಸ ಮಾಡದಿದ್ದರೆ 'issue' ದಾಖಲಿಸಿ. ಚೆನ್ನಾಗಿ ಕೆಲಸ ಮಾಡಿದರೂ ದಾಖಲಿಸಿ. ಯಾವುದೇ ಫಲಿತಾಂಶವು ಪ್ರಾಜೆಕ್ಟ್ ಅನ್ನು ಮುಂದೆ ಕೊಂಡೊಯ್ಯುತ್ತದೆ.

TensorSharp ಎಂಬುದು ಕೇವಲ ಒಂದು Wrapper ಅಲ್ಲ

ಈ ಅಂಶಕ್ಕೆ ಹೆಚ್ಚಿನ ಒತ್ತು ನೀಡಬೇಕಿದೆ. TensorSharp ಎಂಬುದು llama.cpp ಸುತ್ತಲಿನ ಕೇವಲ C# binding ಅಲ್ಲ. ಡೆವಲಪರ್ ಇಡೀ ಇಂಜಿನ್ ಅನ್ನು ಮೊದಲಿನಿಂದම ನಿರ್ಮಿಸಿದ್ದಾರೆ. CPU backend ಸಂಪೂರ್ಣವಾಗಿ C# ಆಗಿದೆ. ನೀವು GPU ಇಲ್ಲದೆ ಇನ್ಫರೆನ್ಸ್ ನಡೆಸಿದಾಗ, ನೀವು C++ ಬೈನರಿಗೆ foreign function interface ಮೂಲಕ ಹೋಗುವ ಬದಲು managed code ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತೀರಿ. ಈ ಪ್ರಾಜೆಕ್ಟ್ CUDA, Apple ನ MLX ಮತ್ತು GGML ಗಾಗಿ ಪ್ರತ್ಯೇಕ backends ಅನ್ನು ಸಹ ಹೊಂದಿದೆ. ಅಂತಹ ಆರ್ಕಿಟೆಕ್ಚರಲ್ ಸ್ವಾತಂತ್ರ್ಯವಿದ್ದರೂ ಸಹ, ಇದರ ಕಾರ್ಯಕ್ಷಮತೆಯು llama.cpp ಗೆ ಸಮನಾಗಿದೆ, ಇದು ಹೆಚ್ಚಿನ ಸ್ಥಳೀಯ ಇನ್ಫರೆನ್ಸ್ ಪ್ರಾಜೆಕ್ಟ್‌ಗಳು ಗುರಿಯಾಗಿಸಿಕೊಂಡಿರುವ ರೆಫರೆನ್ಸ್ ಪಾಯಿಂಟ್ ಆಗಿದೆ. ಆ ಸಮಾನತೆಯನ್ನು ಸಾಧಿಸುವುದು ಕಷ್ಟಕರವಾಗಿದೆ. ಇದರರ್ಥ memory layout, kernel dispatch ಮತ್ತು tensor ops ಎಲ್ಲವೂ ನೈಜ ಲೋಡ್ ಅಡಿಯಲ್ಲಿ ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ.

ಮಾಡೆಲ್ ಬೆಂಬಲವು Gemma4, DiffusionGemma ಮತ್ತು Qwen3.6 ಅನ್ನು ಒಳಗೊಂಡಿದೆ. ರನ್‌ಟೈಮ್ ಮಲ್ಟಿಮೋಡಲ್ ಕೆಲಸವನ್ನೂ ನಿರ್ವಹಿಸುತ್ತದೆ. Vision, audio ಮತ್ತು reasoning ಪೈಪ್‌ಲೈನ್‌ಗಳು ಒಂದೇ ಇಂಜಿನ್ ಮೂಲಕ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ. ನೀವು ಸ್ಕ್ರೀನ್‌ಶಾಟ್‌ಗಳನ್ನು ಓದುವ ಮತ್ತು ಧ್ವನಿ ಆಜ್ಞೆಗಳನ್ನು ಸ್ವೀಕರಿಸುವ ಡೆಸ್ಕ್‌ಟಾಪ್ ಅಸಿಸ್ಟೆಂಟ್ ಅನ್ನು ಪ್ರೊಟೊಟೈಪ್ ಮಾಡುತ್ತಿದ್ದರೆ, ನೀವು ಮೂರು ಪ್ರತ್ಯೇಕ ರನ್‌ಟೈಮ್‌ಗಳನ್ನು ಜೋಡಿಸಿ ಅವುಗಳ ಮೆಮೊರಿ ಬಳಕೆ ನಿಮ್ಮ ಯಂತ್ರಕ್ಕೆ ಹೊಂದಿಕೆಯಾಗಲಿ ಎಂದು ಪ್ರಾರ್ಥಿಸುವ ಅಗತ್ಯವಿಲ್ಲ.

ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಮತ್ತು API ನ ನಮ್ಯತೆ (Flexibility)

TensorSharp Windows, macOS ಮತ್ತು Linux ನಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಹೊಸ Vulkan backend ಈಗಿರುವ CUDA ಮತ್ತು Metal ಮಾರ್ಗಗಳ ಜೊತೆಗೆ ಆ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ ಸುಲಭವಾಗಿ ಹೊಂದಿಕೊಳ್ಳುತ್ತದೆ. ಈ ಇಂಜಿನ್ OpenAI ಮತ್ತು Ollama APIs ಎರಡರೊಂದಿಗೂ ಹೊಂದಾಣಿಕೆಯನ್ನು ತೋರಿಸುತ್ತದೆ. ಈ ಆಯ್ಕೆಯು ಇಂಟಿಗ್ರೇಶನ್‌ನಲ್ಲಿನ ಅಡೆತಡೆಗಳನ್ನು ನಿವಾರಿಸುತ್ತದೆ. ನೀವು ಪ್ರಾಂಪ್ಟ್ ಟೆಂಪ್ಲೇಟ್‌ಗಳನ್ನು ಮರುಬರೆಯುವ ಅಥವಾ ಹೊಸ ರೆಸ್ಪಾನ್ಸ್ ಶೇಪ್ ಅನ್ನು ಪಾರ್ಸ್ ಮಾಡುವ ಅಗತ್ಯವಿಲ್ಲದೆ, ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಕ್ಲೈಂಟ್ ಕೋಡ್ ಅನ್ನು ಸ್ಥಳೀಯ TensorSharp ಸರ್ವರ್‌ಗೆ ಬಳಸಬಹುದು. ಈಗಾಗಲೇ ಆಂತರಿಕವಾಗಿ Ollama ಬಳಸುತ್ತಿರುವ ಅಥವಾ OpenAI ನ REST ಸರ್ಫೇಸ್ ಅನ್ನು ಬಳಸುತ್ತಾ ಬಿಲ್ಡ್ ಮಾಡುತ್ತಿರುವ ತಂಡಗಳಿಗೆ, ಸ್ಥಳೀಯ TensorSharp ಇನ್‌ಸ್ಟೆನ್ಸ್ ಗೆ ಬದಲಾಯಿಸುವುದು ಕೇವಲ ಒಂದು base URL ಅನ್ನು ಬದಲಾಯಿಸುವ ವಿಷಯವಾಗಿದೆ.

ಕೆಲಸ ಮಾಡುವ ಎರವಲು ಪಡೆದ ಆಪ್ಟಿಮೈಸೇಶನ್‌ಗಳು (Optimizations)

ಕಾರ್ಯಕ್ಷಮತೆಯು ಕೇವಲ ಯಾವ API, GPU ಜೊತೆ ಮಾತನಾಡುತ್ತದೆ ಎಂಬುದರ ಮೇಲೆ ಮಾತ್ರ ಅವಲಂಬಿತವಾಗಿಲ್ಲ. TensorSharp ಇತರ ಕಡೆಗಳಲ್ಲಿ ಪ್ರೊಡಕ್ಷನ್‌ನಲ್ಲಿ ಸಾಬೀತಾದ ಹಲವಾರು ಆಪ್ಟಿಮೈಸೇಶನ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿದೆ.

vLLM ನಿಂದ ಎರವಲು ಪಡೆದ Paged KV cache, ಸುದೀರ್ಘ ಸಂಭಾಷಣೆಗಳ ಸಮಯದಲ್ಲಿ ಮೆಮೊರಿ ಅತಿಯಾಗಿ ಹೆಚ್ಚಾಗದಂತೆ ತಡೆಯುತ್ತದೆ. ಪ್ರತಿ ಸೀಕ್ವೆನ್ಸ್‌ಗೆ ಒಂದು ಕಂಟಿಗ್ಯುಯಸ್ ಸ್ಕ್ರ್ಯಾಚ್‌ಪ್ಯಾಡ್ ಅನ್ನು ಮೀಸಲಿಡುವ ಬದಲು, ಇಂಜಿನ್ ನಿಗದಿತ ಗಾತ್ರದ ಪೇಜ್‌ಗಳನ್ನು ಹಂಚಿಕೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ಅವುಗಳನ್ನು ಬೇಡಿಕೆಯ ಮೇರೆಗೆ ಮ್ಯಾಪ್ ಮಾಡುತ್ತದೆ. RAM ಬಳಕೆ ಏರಿಕೆಯಾಗುವುದನ್ನು ಗಮನಿಸದೆ ನೀವು ಕಾನ್ಟೆಕ್ಸ್ಟ್ ವಿಂಡೋಗಳನ್ನು ಹೆಚ್ಚು ಕಾಲ ತೆರೆದಿಡಬಹುದು.

Continuous batching, also from vLLM, improves throughput. The engine can slip new requests into active batches instead of waiting for the current group to finish. If one user’s prompt is ten tokens and another’s is two hundred, the hardware stays busier and average latency drops.

For Mixture-of-Experts models, TensorSharp implements an SSD-based cache strategy drawn from oMLX. Frequently accessed expert weights sit ready on fast storage rather than fighting for system RAM. On machines with limited memory but decent NVMe drives, this keeps MoE architectures usable.

Quantization follows the GGUF standard established by llama.cpp. Your quantized 4-bit and 5-bit models load directly without a conversion step.

The Real Takeaway

Vulkan support turns TensorSharp from an interesting C# experiment into a practical inference option for heterogeneous hardware. The roadmap is clear: validate across AMD and Intel discrete silicon, then tighten the implementation with a native Vulkan backend. If you have an AMD card in your workstation or laptop, run the build and share your results. That feedback loop is what hardens experimental code into something you can ship.

You can find the release details on the developer’s write-up. If the project saves you from juggling CUDA toolkits or wrestling with macOS version locks, leave a star on the repository. For ongoing discussion and community testing threads, the Telegram group stays open.