unsloth
Unsloth Studio is a web UI for training and running open models like Gemma 4, Qwen3.6, DeepSeek, gpt-oss locally.
Top Related Projects
DeepSpeed is a deep learning optimization library that makes distributed training and inference easy, efficient, and effective.
🤗 PEFT: State-of-the-art Parameter-Efficient Fine-Tuning.
Accessible large language models via k-bit quantization for PyTorch.
Code for loralib, an implementation of "LoRA: Low-Rank Adaptation of Large Language Models"
An implementation of model parallel autoregressive transformers on GPUs, based on the Megatron and DeepSpeed libraries
Inference code for Llama models
Quick Overview
Unsloth is an open-source project aimed at accelerating Large Language Model (LLM) fine-tuning. It offers significant speed improvements and memory efficiency for training and inference tasks, particularly for models like LLaMA 2. Unsloth is designed to be easy to use and integrate with existing workflows.
Pros
- Substantial speed improvements in LLM fine-tuning (up to 3x faster)
- Reduced memory usage, allowing for larger batch sizes and more efficient training
- Easy integration with popular libraries like Hugging Face Transformers
- Supports both training and inference optimizations
Cons
- Currently limited to specific model architectures (e.g., LLaMA 2)
- May require some familiarity with LLM fine-tuning concepts
- Potential compatibility issues with certain hardware setups or environments
- Still in active development, which may lead to frequent changes or updates
Code Examples
- Basic fine-tuning setup:
from unsloth import FastLanguageModel
model, tokenizer = FastLanguageModel.from_pretrained("meta-llama/Llama-2-7b-hf")
model = FastLanguageModel.prepare_model(model)
# Fine-tuning code here
- Enabling 4-bit quantization:
model, tokenizer = FastLanguageModel.from_pretrained(
"meta-llama/Llama-2-7b-hf",
quantization="4bit",
device_map="auto"
)
- Inference optimization:
from unsloth import FastLanguageModel, optimize_model
model, tokenizer = FastLanguageModel.from_pretrained("meta-llama/Llama-2-7b-hf")
model = optimize_model(model)
# Inference code here
Getting Started
To get started with Unsloth, follow these steps:
-
Install the library:
pip install unsloth -
Import and use in your project:
from unsloth import FastLanguageModel model, tokenizer = FastLanguageModel.from_pretrained("meta-llama/Llama-2-7b-hf") model = FastLanguageModel.prepare_model(model) # Your fine-tuning or inference code here -
For more detailed instructions and advanced usage, refer to the project's documentation on GitHub.
Competitor Comparisons
DeepSpeed is a deep learning optimization library that makes distributed training and inference easy, efficient, and effective.
Pros of DeepSpeed
- More comprehensive optimization toolkit for deep learning
- Supports a wider range of models and training scenarios
- Extensive documentation and community support
Cons of DeepSpeed
- Steeper learning curve for beginners
- May require more configuration for optimal performance
- Potentially higher overhead for simpler use cases
Code Comparison
DeepSpeed:
import deepspeed
model_engine, optimizer, _, _ = deepspeed.initialize(
args=args,
model=model,
model_parameters=params
)
Unsloth:
from unsloth import FastLanguageModel
model, tokenizer = FastLanguageModel.from_pretrained("mistralai/Mistral-7B-v0.1")
Key Differences
- DeepSpeed offers a broader set of optimization techniques
- Unsloth focuses specifically on LLM fine-tuning and inference
- DeepSpeed requires more setup but provides greater flexibility
- Unsloth aims for simplicity and ease of use in LLM workflows
Use Cases
- DeepSpeed: Large-scale distributed training, complex model architectures
- Unsloth: Quick LLM fine-tuning, efficient inference on consumer hardware
Community and Support
- DeepSpeed: Larger community, extensive documentation, regular updates
- Unsloth: Newer project, growing community, focused on LLM-specific optimizations
🤗 PEFT: State-of-the-art Parameter-Efficient Fine-Tuning.
Pros of PEFT
- Broader compatibility with various model architectures
- More extensive documentation and community support
- Wider range of parameter-efficient fine-tuning techniques
Cons of PEFT
- Generally slower training and inference compared to Unsloth
- May require more manual configuration and setup
- Less focus on memory optimization for consumer-grade hardware
Code Comparison
PEFT example:
from peft import get_peft_model, LoraConfig
peft_config = LoraConfig(task_type="CAUSAL_LM", r=8, lora_alpha=32, lora_dropout=0.1)
model = get_peft_model(model, peft_config)
Unsloth example:
from unsloth import FastLanguageModel
model, tokenizer = FastLanguageModel.from_pretrained("mistralai/Mistral-7B-v0.1")
model = model.to_lora(r=8, target_modules=["q_proj", "k_proj", "v_proj", "o_proj"])
Both libraries aim to make fine-tuning large language models more efficient, but Unsloth focuses on speed and memory optimization for consumer hardware, while PEFT offers a wider range of techniques and broader compatibility across different model architectures.
Accessible large language models via k-bit quantization for PyTorch.
Pros of bitsandbytes
- More established and widely used in the machine learning community
- Offers a broader range of quantization and optimization techniques
- Better documentation and community support
Cons of bitsandbytes
- Less focused on specific LLM fine-tuning tasks
- May require more setup and configuration for certain use cases
- Potentially slower for some LLM-specific operations
Code Comparison
bitsandbytes:
import bitsandbytes as bnb
optimizer = bnb.optim.Adam8bit(model.parameters(), lr=1e-3)
unsloth:
from unsloth import FastLanguageModel
model, tokenizer = FastLanguageModel.from_pretrained("mistralai/Mistral-7B-v0.1")
Summary
bitsandbytes is a more general-purpose library for quantization and optimization in machine learning, offering a wide range of techniques. It's well-established and has strong community support. However, it may require more setup for specific LLM tasks.
unsloth, on the other hand, is more focused on LLM fine-tuning and optimization. It offers simpler integration for certain LLM tasks but may have a narrower scope of applications compared to bitsandbytes.
The choice between the two depends on the specific use case, with bitsandbytes being more versatile and unsloth potentially offering easier integration for LLM-specific tasks.
Code for loralib, an implementation of "LoRA: Low-Rank Adaptation of Large Language Models"
Pros of LoRA
- Established and widely adopted in the ML community
- Extensive documentation and research backing
- Supports a broader range of model architectures
Cons of LoRA
- Less focus on optimization and speed improvements
- May require more manual configuration and tuning
- Limited built-in support for specific model families
Code Comparison
LoRA:
import loralib as lora
# Apply LoRA to a linear layer
lora_layer = lora.Linear(in_features, out_features, r=rank)
Unsloth:
from unsloth import FastLanguageModel
# Load and patch a model with Unsloth optimizations
model, tokenizer = FastLanguageModel.from_pretrained("mistralai/Mistral-7B-v0.1")
Key Differences
- LoRA focuses on parameter-efficient fine-tuning, while Unsloth emphasizes speed and memory optimization
- Unsloth provides more out-of-the-box optimizations for specific model families (e.g., LLMs)
- LoRA offers greater flexibility for custom architectures, whereas Unsloth targets pre-built models
Use Cases
- LoRA: Ideal for researchers and developers working with diverse model architectures
- Unsloth: Better suited for practitioners looking to quickly optimize and deploy large language models
Community and Support
- LoRA: Larger community, more third-party integrations
- Unsloth: Newer project, focused support for specific use cases
An implementation of model parallel autoregressive transformers on GPUs, based on the Megatron and DeepSpeed libraries
Pros of gpt-neox
- Designed for training large language models from scratch
- Supports distributed training across multiple GPUs and nodes
- Includes tools for dataset preparation and tokenization
Cons of gpt-neox
- Requires significant computational resources for training
- More complex setup and configuration process
- Less focused on fine-tuning existing models
Code Comparison
gpt-neox:
from megatron.neox_arguments import NeoXArgs
from megatron.global_vars import set_global_variables, get_tokenizer
from megatron.training import pretrain
neox_args = NeoXArgs.from_ymls(["configs/my_config.yml"])
set_global_variables(neox_args)
unsloth:
from unsloth import FastLanguageModel
model, tokenizer = FastLanguageModel.from_pretrained("mistralai/Mistral-7B-v0.1")
model = FastLanguageModel.get_peft_model(model, r=16, target_modules=["q_proj", "k_proj", "v_proj", "o_proj"])
gpt-neox is better suited for training large models from scratch with distributed computing, while unsloth focuses on efficient fine-tuning of existing models with optimized performance. gpt-neox offers more flexibility in model architecture and training process, but requires more setup and resources. unsloth provides a simpler API for quick fine-tuning and inference optimization.
Inference code for Llama models
Pros of Llama
- Developed by Meta, benefiting from extensive resources and research
- Supports a wide range of language tasks and applications
- Has a large and active community, contributing to its development and ecosystem
Cons of Llama
- Requires significant computational resources for training and inference
- May have limitations in terms of fine-tuning and customization for specific use cases
- Can be complex to set up and use for beginners
Code Comparison
Llama:
from transformers import LlamaTokenizer, LlamaForCausalLM
tokenizer = LlamaTokenizer.from_pretrained("meta-llama/Llama-2-7b-hf")
model = LlamaForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf")
input_text = "Hello, how are you?"
input_ids = tokenizer(input_text, return_tensors="pt").input_ids
output = model.generate(input_ids, max_length=50)
Unsloth:
from unsloth import FastLanguageModel
model, tokenizer = FastLanguageModel.from_pretrained("meta-llama/Llama-2-7b-hf")
input_text = "Hello, how are you?"
output = model.generate(tokenizer(input_text, return_tensors="pt").input_ids)
The Unsloth implementation appears more concise and potentially easier to use, while the Llama code offers more explicit control over the model and tokenizer initialization.
Convert 
designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual CopilotREADME
Unsloth Studio lets you run and train models locally.
Features ⢠Quickstart ⢠Notebooks ⢠Documentation
â¡ Get started
macOS, Linux, WSL:
curl -fsSL https://unsloth.ai/install.sh | sh
Windows:
irm https://unsloth.ai/install.ps1 | iex
Community:
â Features
Unsloth Studio (Beta) lets you run and train text, audio, embedding, vision models on Windows, Linux and macOS.
Inference
- Search + download + run models including GGUF, LoRA adapters, safetensors
- Export models: Save or export models to GGUF, 16-bit safetensors and other formats.
- Tool calling: Support for self-healing tool calling and web search
- Code execution: lets LLMs test code in Claude artifacts and sandbox environments
- API inference endpoint: Deploy and run local LLMs in Claude Code, Codex tools with Unsloth
- Auto set inference settings and customize chat templates.
- We work directly with teams behind gpt-oss, Qwen3, Llama 4, Mistral, Gemma 1-3, and Phi-4, where weâve fixed bugs that improve model accuracy.
- Chat with images, audio, PDFs, code, DOCX and more. Connect API providers (OpenAI, Anthropic) or servers (vLLM, Ollama).
Training
- Train and RL 500+ models up to 2x faster with up to 70% less VRAM, with no accuracy loss.
- Custom Triton and mathematical kernels. See some collabs we did with PyTorch and Hugging Face.
- Data Recipes: Auto-create datasets from PDF, CSV, DOCX etc. Edit data in a visual-node workflow.
- Reinforcement Learning (RL): The most efficient RL library, using 80% less VRAM for GRPO, FP8 etc.
- Supports full fine-tuning, RL, pretraining, 4-bit, 16-bit and, FP8 training.
- Observability: Monitor training live, track loss and GPU usage and customize graphs.
- Multi-GPU training is supported, with major improvements coming soon.
ð¥ Install
Unsloth can be used in two ways: through Unsloth Studio, the web UI, or through Unsloth Core, the code-based version. Each has different requirements.
Unsloth Studio (web UI)
Unsloth Studio (Beta) works on Windows, Linux, WSL and macOS.
- CPU: Supported for Chat and Data Recipes currently
- NVIDIA: Training works on RTX 30/40/50, Blackwell, DGX Spark, Station and more
- macOS: Training, MLX and GGUF inference are ALL supported.
- AMD: Chat + Data works. Train with Unsloth Core. Studio support is out soon.
- Multi-GPU: Available now, with a major upgrade on the way
macOS, Linux, WSL:
curl -fsSL https://unsloth.ai/install.sh | sh
Use the same command to update.
Windows:
irm https://unsloth.ai/install.ps1 | iex
Use the same command to update.
Launch
unsloth studio -p 8888
For cloud or global access, add -H 0.0.0.0. By default, Unsloth is accessible only locally.
To reach Studio over HTTPS, use unsloth studio --secure. Studio stays bound to localhost and is reached only through a free Cloudflare tunnel, which publishes it at a public https://*.trycloudflare.com URL (it fails closed if the tunnel can't start, so the raw port is never exposed). This makes Studio reachable from the internet, so anyone with the link and API key can use it and run code: keep your API key private (see Remote access below).
Docker
Use our Docker image unsloth/unsloth container. Run:
docker run -d -e JUPYTER_PASSWORD="mypassword" \
-p 8888:8888 -p 8000:8000 -p 2222:22 \
-v $(pwd)/work:/workspace/work \
--gpus all \
unsloth/unsloth
Developer, Nightly, Uninstall
To see developer, nightly and uninstallation etc. instructions, see advanced installation.
Unsloth Core (code-based)
Linux, WSL:
curl -LsSf https://astral.sh/uv/install.sh | sh
uv venv unsloth_env --python 3.13
source unsloth_env/bin/activate
uv pip install unsloth --torch-backend=auto
Windows:
winget install -e --id Python.Python.3.13
winget install --id=astral-sh.uv -e
uv venv unsloth_env --python 3.13
.\unsloth_env\Scripts\activate
uv pip install unsloth --torch-backend=auto
For Windows, pip install unsloth works only if you have PyTorch installed. Read our Windows Guide.
You can use the same Docker image as Unsloth Studio.
AMD, Intel:
For RTX 50x, B200, 6000 GPUs: uv pip install unsloth --torch-backend=auto. Read our guides for: Blackwell and DGX Spark.
To install Unsloth on AMD and Intel GPUs, follow our AMD Guide and Intel Guide.
ð Free Notebooks
Train for free with our notebooks. You can use our new free Unsloth Studio notebook to run and train models for free in a web UI. Read our guide. Add dataset, run, then deploy your trained model.
| Model | Free Notebooks | Performance | Memory use |
|---|---|---|---|
| Gemma 4 (E2B) | â¶ï¸ Start for free | 1.5x faster | 50% less |
| Qwen3.5 (4B) | â¶ï¸ Start for free | 1.5x faster | 60% less |
| gpt-oss (20B) | â¶ï¸ Start for free | 2x faster | 70% less |
| Qwen3.5 GSPO | â¶ï¸ Start for free | 2x faster | 70% less |
| gpt-oss (20B): GRPO | â¶ï¸ Start for free | 2x faster | 80% less |
| Qwen3: Advanced GRPO | â¶ï¸ Start for free | 2x faster | 70% less |
| embeddinggemma (300M) | â¶ï¸ Start for free | 2x faster | 20% less |
| Mistral Ministral 3 (3B) | â¶ï¸ Start for free | 1.5x faster | 60% less |
| Llama 3.1 (8B) Alpaca | â¶ï¸ Start for free | 2x faster | 70% less |
| Llama 3.2 Conversational | â¶ï¸ Start for free | 2x faster | 70% less |
| Orpheus-TTS (3B) | â¶ï¸ Start for free | 1.5x faster | 50% less |
- See all our notebooks for: Kaggle, GRPO, TTS, embedding & Vision
- See all our models and all our notebooks
- See detailed documentation for Unsloth here
𦥠Unsloth News
- Connections: Connect any API provider (OpenAI, Anthropic) or server (vLLM, Ollama). Guide
- MTP: Run Qwen3.6 MTP in Unsloth. MTP settings are autoset specific to your hardware. Guide
- API inference endpoint: Deploy and run local LLMs in Claude Code, Codex tools. Guide
- Qwen3.6: Qwen3.6-35B-A3B can now be trained and run in Unsloth Studio. Blog
- Gemma 4: Run and train Googleâs new models directly in Unsloth. Blog
- Introducing Unsloth Studio: our new web UI for running and training LLMs. Blog
- Qwen3.5 - 0.8B, 2B, 4B, 9B, 27B, 35-A3B, 112B-A10B are now supported. Guide + notebooks
- Train MoE LLMs 12x faster with 35% less VRAM - DeepSeek, GLM, Qwen and gpt-oss. Blog
- Embedding models: Unsloth now supports ~1.8-3.3x faster embedding fine-tuning. Blog ⢠Notebooks
- New 7x longer context RL vs. all other setups, via our new batching algorithms. Blog
- New RoPE & MLP Triton Kernels & Padding Free + Packing: 3x faster training & 30% less VRAM. Blog
- 500K Context: Training a 20B model with >500K context is now possible on an 80GB GPU. Blog
- FP8 & Vision RL: You can now do FP8 & VLM GRPO on consumer GPUs. FP8 Blog ⢠Vision RL
ð¥ Advanced Installation
The below advanced instructions are for Unsloth Studio. For Unsloth Core advanced installation, view our docs.
Developer / Nightly / Experimental installs: macOS, Linux, WSL:
The developer install builds from the main branch, which is the latest (nightly) source.
git clone https://github.com/unslothai/unsloth
cd unsloth
./install.sh --local
unsloth studio -p 8888
To install into an isolated location (its own virtual env, auth/, studio.db, cache and llama.cpp build), set UNSLOTH_STUDIO_HOME and pass it again at launch:
UNSLOTH_STUDIO_HOME="$PWD/.studio" ./install.sh --local
UNSLOTH_STUDIO_HOME="$PWD/.studio" unsloth studio -p 8888
Then to update :
cd unsloth && git pull
./install.sh --local
unsloth studio -p 8888
Developer / Nightly / Experimental installs: Windows PowerShell:
The developer install builds from the main branch, which is the latest (nightly) source.
git clone https://github.com/unslothai/unsloth.git
cd unsloth
Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass
.\install.ps1 --local
unsloth studio -p 8888
To install into an isolated location (its own virtual env, auth/, studio.db, cache and llama.cpp build), set UNSLOTH_STUDIO_HOME and pass it again at launch:
$env:UNSLOTH_STUDIO_HOME="$PWD\.studio"; .\install.ps1 --local
$env:UNSLOTH_STUDIO_HOME="$PWD\.studio"; unsloth studio -p 8888
Then to update :
cd unsloth; git pull
.\install.ps1 --local
unsloth studio -p 8888
Remote access: --secure (HTTPS tunnel) vs raw port
By default unsloth studio binds to 127.0.0.1 (this machine only). To reach it from another device, pick one of:
--secure(recommended): serve only through a free Cloudflare HTTPS link. Studio stays bound to localhost and the tunnel provides the public URL; it fails closed (does not start) if the tunnel can't come up, so the raw port is never exposed.
unsloth studio --secure -p 8888
-H 0.0.0.0: bind the raw port on all network interfaces, reachable from anywhere on the network. This also starts a public Cloudflare quick tunnel by default, which publishes an internet-reachablehttps://*.trycloudflare.comURL even behind a firewall. Both the raw port and the tunnel expose Studio beyond this machine, so only use this on a network you trust; pass--no-cloudflareto drop the public link while keeping the network bind.
unsloth studio -H 0.0.0.0 -p 8888
Server-side tools (web search, Python and terminal code execution) run as your user and are on by default. Anyone who can reach the server with the API key can run code on this machine, so keep your API key private and pass --disable-tools when exposing Studio.
Advanced launch options
Installer options can be passed as environment variables. On macOS, Linux and WSL place the variable after the pipe so the shell passes it to sh; on Windows set it with $env: before piping to iex.
Skip PyTorch (GGUF-only mode):
curl -fsSL https://unsloth.ai/install.sh | UNSLOTH_NO_TORCH=1 sh
$env:UNSLOTH_NO_TORCH=1; irm https://unsloth.ai/install.ps1 | iex
Skip the post-install prompt that starts Studio (useful for automated installs):
curl -fsSL https://unsloth.ai/install.sh | UNSLOTH_SKIP_AUTOSTART=1 sh
$env:UNSLOTH_SKIP_AUTOSTART=1; irm https://unsloth.ai/install.ps1 | iex
Pin the Python version:
curl -fsSL https://unsloth.ai/install.sh | UNSLOTH_PYTHON=3.12 sh
$env:UNSLOTH_PYTHON='3.12'; irm https://unsloth.ai/install.ps1 | iex
Install to a custom location with UNSLOTH_STUDIO_HOME:
curl -fsSL https://unsloth.ai/install.sh | UNSLOTH_STUDIO_HOME=/abs/path sh
$env:UNSLOTH_STUDIO_HOME='C:\path'; irm https://unsloth.ai/install.ps1 | iex
On macOS, the installer defaults to the system certificate store (UV_SYSTEM_CERTS=1) so uv trusts the CAs in your Keychain, needed behind TLS-inspecting proxies (Cisco Umbrella, Zscaler, etc.). Opt out with:
curl -fsSL https://unsloth.ai/install.sh | UV_SYSTEM_CERTS=0 sh
Point the frontend build at a corporate npm mirror/proxy with UNSLOTH_NPM_REGISTRY (for the developer install behind a firewall that blocks registry.npmjs.org):
UNSLOTH_NPM_REGISTRY=https://artifactory.example.com/api/npm/npm/ ./install.sh --local
$env:UNSLOTH_NPM_REGISTRY='https://artifactory.example.com/api/npm/npm/'; .\install.ps1 --local
It is threaded as --registry into the Studio frontend npm/bun installs; the supply-chain locks (7-day min-release-age, exact version pins) stay in force.
Cap Studio's native CPU thread pools on high-core hosts: UNSLOTH_CPU_THREADS=8 unsloth studio -p 8888.
Uninstall
The recommended way to fully remove Unsloth Studio is the matching uninstall script for your OS. It stops any running servers, removes the install dir, the launcher data dir, the desktop shortcut, and any platform-specific entries (macOS .app bundle + Launch Services on Mac; Start Menu, HKCU\Software\Unsloth registry key and user PATH entries on Windows):
- â MacOS, WSL, Linux:
curl -fsSL https://raw.githubusercontent.com/unslothai/unsloth/main/scripts/uninstall.sh | sh - â Windows (PowerShell):
irm https://raw.githubusercontent.com/unslothai/unsloth/main/scripts/uninstall.ps1 | iex
If you only want to drop the install dir and keep the launcher/shortcut for a later reinstall, you can instead run rm -rf ~/.unsloth/studio (Mac/Linux/WSL) or Remove-Item -Recurse -Force "$HOME\.unsloth\studio" (Windows). The model cache at ~/.cache/huggingface is not touched by any of these.
For more info, see our docs.
Deleting model files
You can delete old model files either from the bin icon in model search or by removing the relevant cached model folder from the default Hugging Face cache directory. By default, HF uses:
- â MacOS, Linux, WSL:
~/.cache/huggingface/hub/ - â Windows:
%USERPROFILE%\.cache\huggingface\hub\
ð Community and Links
| Type | Links |
|---|---|
 Â Discord | Join Discord server |
 Â r/unsloth Reddit | Join Reddit community |
| ð Documentation & Wiki | Read Our Docs |
_logo_late_2025.svg){kind=logo} Â Twitter (aka X) | Follow us on X |
| ð® Our Models | Unsloth Catalog |
| âï¸ Blog | Read our Blogs |
Citation
You can cite the Unsloth repo as follows:
@software{unsloth,
author = {Daniel Han, Michael Han and Unsloth team},
title = {Unsloth},
url = {https://github.com/unslothai/unsloth},
year = {2023}
}
If you trained a model with ð¦¥Unsloth, you can use this cool sticker!  
License
Unsloth uses a dual-licensing model of Apache 2.0 and AGPL-3.0. The core Unsloth package remains licensed under Apache 2.0, while certain optional components, such as the Unsloth Studio UI are licensed under the open-source license AGPL-3.0.
This structure helps support ongoing Unsloth development while keeping the project open source and enabling the broader ecosystem to continue growing.
Thank You to
- The llama.cpp library that lets users run and save models with Unsloth
- The Hugging Face team and their libraries: transformers and TRL
- The Pytorch and Torch AO team for their contributions
- NVIDIA for their NeMo DataDesigner library and their contributions
- And of course for every single person who has contributed or has used Unsloth!
Top Related Projects
DeepSpeed is a deep learning optimization library that makes distributed training and inference easy, efficient, and effective.
🤗 PEFT: State-of-the-art Parameter-Efficient Fine-Tuning.
Accessible large language models via k-bit quantization for PyTorch.
Code for loralib, an implementation of "LoRA: Low-Rank Adaptation of Large Language Models"
An implementation of model parallel autoregressive transformers on GPUs, based on the Megatron and DeepSpeed libraries
Inference code for Llama models
Convert designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual Copilot