Granite

Generates syntactically correct and semantically sound code across 116 programming languages by leveraging a decoder-only transformer architecture trained on 3-4 trillion tokens of language-specific code data during Phase 1 pre-training. The model learns language-specific patterns, idioms, and conventions through exposure to diverse codebases, enabling it to produce idiomatic code for any supported language without explicit language-switching logic. This is achieved through a unified token vocabulary that represents code tokens across all 116 languages, allowing the model to generalize code generation patterns across linguistic boundaries.

Executes diverse code-related tasks (generation, explanation, bug fixing, editing, translation) through instruction-following models fine-tuned on a hybrid dataset combining Git commits paired with human instructions and synthetically generated code instruction data. The Instruct variants use supervised fine-tuning (SFT) on curated instruction-response pairs derived from real Git history and synthetic instruction generation, enabling the model to understand and execute complex multi-step coding tasks expressed in natural language. This two-phase approach (base model pre-training followed by instruction tuning) allows the model to maintain general code understanding while specializing in following user directives.

Translates code from one programming language to another while preserving algorithmic intent and adapting to target language idioms and conventions. The model learns language-specific patterns during pre-training on 116 languages, enabling it to understand semantic equivalence across languages and generate idiomatic code in the target language rather than literal translations. This is achieved through the unified token vocabulary trained on diverse language codebases, allowing the model to map concepts across languages and apply target-language conventions.

Performs targeted code edits and refactoring operations (renaming, extracting functions, simplifying logic) while preserving surrounding code context and maintaining semantic correctness. The model understands code structure through transformer attention mechanisms and can make surgical edits to specific code regions without corrupting the broader codebase. This is enabled by the decoder-only architecture which processes code sequentially and learns to understand code dependencies and scope through pre-training on diverse codebases.

Generates code while maintaining enterprise compliance through a rigorous data processing pipeline that filters training data by license permissibility, redacts personally identifiable information (PII) using token replacement, and scans for malware using ClamAV. The model is trained exclusively on code that meets IBM's AI Ethics principles and license compatibility requirements, ensuring generated code does not inadvertently reproduce copyrighted or restricted-license code. PII redaction replaces names, emails, and identifiers with standardized tokens during training, reducing the likelihood of the model memorizing and reproducing sensitive information in generated code.

Provides four parameter size variants (3B, 8B, 20B, 34B) with corresponding context window options (2K, 4K, 8K tokens) allowing deployment across diverse hardware constraints from edge devices to data centers. Each model size is a complete, independently trained decoder-only transformer optimized for its parameter budget, enabling developers to trade off model capability for inference latency and memory footprint. The context window sizing (e.g., granite-3b-code-base-2k has 2K context, granite-20b-code-base-8k has 8K context) allows selection based on typical code snippet sizes and available VRAM, with larger models supporting longer context for multi-file code understanding.

Trains models through a two-phase approach: Phase 1 trains on 3-4 trillion tokens of pure code data to build strong code understanding, then Phase 2 continues training on 500 billion tokens with an 80% code to 20% natural language mixture to improve code explanation and reasoning capabilities. This curriculum learning approach allows the model to first master code syntax and patterns, then learn to reason about and explain code in natural language. The 80/20 mixture ratio is empirically optimized to balance code generation quality with natural language understanding, preventing the model from forgetting code patterns while gaining language reasoning abilities.

Removes duplicate and near-duplicate code from training data using both exact matching (byte-level hashing) and fuzzy matching (semantic similarity detection) to prevent the model from memorizing redundant patterns and reduce training data size. Exact deduplication identifies identical code blocks using hash-based comparison, while fuzzy deduplication detects semantically similar code (e.g., same algorithm with different variable names) using techniques like MinHash or locality-sensitive hashing. This two-tier approach reduces training data redundancy while preserving diverse implementations of the same patterns, improving model generalization and reducing memorization risk.

Reduces the likelihood of generating harmful, malicious, or unsafe code by applying content filtering during the data processing pipeline before training begins. The filtering identifies and removes code patterns associated with common vulnerabilities (SQL injection, buffer overflows), malware signatures, and unsafe practices, preventing the model from learning these patterns during pre-training. This approach differs from post-hoc filtering at inference time — the model is trained on sanitized data, making harmful code generation less likely to occur naturally rather than being suppressed by guardrails.

Enables organizations to fine-tune base Granite models on proprietary code instruction datasets to specialize models for domain-specific tasks, coding standards, or internal APIs. The fine-tuning process uses supervised fine-tuning (SFT) on instruction-response pairs, allowing teams to adapt the model to their codebase patterns, internal libraries, and coding conventions without retraining from scratch. This capability leverages the base model's pre-trained code understanding while specializing it for specific domains (e.g., Kubernetes operators, financial trading systems, healthcare data pipelines).

Generates natural language explanations of code functionality, behavior, and intent by leveraging the Phase 2 training mixture (80% code, 20% natural language) which teaches the model to reason about and articulate code semantics. The model can produce inline comments, docstrings, README documentation, and high-level summaries of code blocks by understanding code structure and translating it to natural language. This capability is enabled by the two-phase training approach where Phase 2 exposure to natural language paired with code teaches the model to bridge the code-to-text gap.

Identifies and fixes bugs in code by understanding bug descriptions in natural language and generating corrected code through the instruction-tuned model variants. The model learns to recognize common bug patterns (off-by-one errors, null pointer dereferences, logic errors) from training on Git commits that pair bug-fixing code changes with commit messages describing the fix. This enables the model to take broken code and a description of the issue, then generate corrected code that addresses the specific problem.