From 65b92f4fda2eb96eb1cc6eff4b61a8e003c440f4 Mon Sep 17 00:00:00 2001 From: serjikibm Date: Fri, 21 Aug 2026 14:44:45 -0400 Subject: [PATCH 1/6] add new 4.2 page, no url changes Signed-off-by: serjikibm --- .../models/{granite.mdx => granite4-0.mdx} | 0 granite/docs/models/granite4-2.mdx | 215 ++++++++++++++++++ sidebars.ts | 1 + src/pages/index.tsx | 2 +- 4 files changed, 217 insertions(+), 1 deletion(-) rename granite/docs/models/{granite.mdx => granite4-0.mdx} (100%) create mode 100644 granite/docs/models/granite4-2.mdx diff --git a/granite/docs/models/granite.mdx b/granite/docs/models/granite4-0.mdx similarity index 100% rename from granite/docs/models/granite.mdx rename to granite/docs/models/granite4-0.mdx diff --git a/granite/docs/models/granite4-2.mdx b/granite/docs/models/granite4-2.mdx new file mode 100644 index 0000000..4e08354 --- /dev/null +++ b/granite/docs/models/granite4-2.mdx @@ -0,0 +1,215 @@ +--- +title: "Granite 4.2" +description: "Dense reasoning language model family in 3B, 8B, and 30B sizes with built-in chain-of-thought thinking, flexible thinking modes, and reasoning-augmented tool calling." +sidebar_custom_props: + icon: "sparkles" +--- + + + + View the full Granite 4.2 collection on Hugging Face + + + Code examples, tools and documentation + + + +## Overview + +**Granite 4.2** is a family of dense reasoning language models available in three sizes: 3B, 8B, and 30B parameters. Post-trained from the Granite 4.1 base models, the Granite 4.2 generation introduces native reasoning (thinking) capabilities, allowing models to perform step-by-step chain-of-thought reasoning before producing final answers. This significantly improves performance on complex math, coding, multi-step logic, and agentic tool-calling tasks. + +### Model Variants + +- **granite-4.2-3b**: Compact reasoning model optimized for edge deployment and resource-constrained environments +- **granite-4.2-8b**: Balanced reasoning model for general-purpose enterprise applications +- **granite-4.2-30b**: Flagship reasoning model for complex reasoning and specialized tasks + +All models natively support a 128K context window (with long-context extension to 512K) and are released under the Apache 2.0 license, enabling unrestricted commercial and academic use. + +### Key Capabilities + +**Built-in Reasoning**: Granite 4.2 features native chain-of-thought reasoning inside `...` tags, significantly improving performance on math, coding, and complex multi-step problems. + +**Flexible Thinking Modes**: Seamlessly switch between full thinking (default), non-thinking, and low-effort modes within a single model, allowing users to balance depth vs. latency on a per-query basis. + +**Reasoning-Augmented Tool Calling**: The model reasons about which tools to invoke and why before making the call, producing more accurate function calls for agentic workflows. + +**Multilingual Dialog**: Granite 4.2 is tested across English, German, Spanish, French, Japanese, Portuguese, Arabic, Czech, Italian, Korean, Dutch, and Chinese. + +## Getting Started + +First, install the required libraries: + + + +```bash Install +pip install torch torchvision torchaudio +pip install accelerate +pip install transformers +``` + + + +### Generation + +This is a simple example of how to use the Granite-4.2-30B model in thinking mode: + + + +```python Python +import torch +from transformers import AutoModelForCausalLM, AutoTokenizer + +model_path = "ibm-granite/granite-4.2-30b" +tokenizer = AutoTokenizer.from_pretrained(model_path) +# drop device_map if running on CPU +model = AutoModelForCausalLM.from_pretrained(model_path, device_map="cuda", torch_dtype=torch.bfloat16) +model.eval() + +# change input text as desired +messages = [ + { "role": "user", "content": "How many r's are in the word 'strawberry'?" }, +] + +text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True, enable_thinking=True) +inputs = tokenizer(text, return_tensors="pt").to(model.device) + +# generate output tokens +output = model.generate(**inputs, max_new_tokens=8192, temperature=1.0, top_p=0.95, do_sample=True) + +# decode output tokens into text +print(tokenizer.decode(output[0][inputs.input_ids.shape[-1]:], skip_special_tokens=False)) +``` + + + +Expected output: + + + +```text Output + +First, I need to write out the word: s t r a w b e r r y. +Now, I count the number of 'r' letters: one at position 3, one at position 8, one at position 9. +Total r's = 3. + +There are **3** r's in the word "strawberry".<|im_end|> +``` + + + +> **Generation parameters:** Use `temperature=1.0` and `top_p=0.95` across **all tasks and serving backends**, including general chat, reasoning, and tool calling. + +### Thinking Modes + +Granite 4.2 supports three thinking modes, selected via chat-template parameters: + +| Mode | Template Parameters | Behavior | +|:-----|:-------------------|:---------| +| **Thinking** (default) | `enable_thinking=True` | Full chain-of-thought reasoning inside `...` | +| **Non-thinking** | `enable_thinking=False` | Direct answer with no reasoning overhead | +| **Low-effort** | `enable_thinking=True, low_effort=True` | Brief reasoning for simpler queries | + +### Tool Calling + +Granite 4.2 supports tool calling with integrated reasoning — the model thinks about which tool to call and why before making the call. Define a list of tools using OpenAI's function definition schema: + + + +```python Python +import torch +from transformers import AutoModelForCausalLM, AutoTokenizer + +model_path = "ibm-granite/granite-4.2-30b" +tokenizer = AutoTokenizer.from_pretrained(model_path) +# drop device_map if running on CPU +model = AutoModelForCausalLM.from_pretrained(model_path, device_map="cuda", torch_dtype=torch.bfloat16) +model.eval() + +tools = [ + { + "type": "function", + "function": { + "name": "get_current_weather", + "description": "Get the current weather for a specified city.", + "parameters": { + "type": "object", + "properties": { + "city": { + "type": "string", + "description": "Name of the city" + } + }, + "required": ["city"] + } + } + } +] + +# change input text as desired +messages = [ + { "role": "user", "content": "What's the weather like in Boston right now?" }, +] + +text = tokenizer.apply_chat_template(messages, tokenize=False, tools=tools, + add_generation_prompt=True, enable_thinking=True) +inputs = tokenizer(text, return_tensors="pt").to(model.device) + +# generate output tokens +output = model.generate(**inputs, max_new_tokens=4096, temperature=1.0, top_p=0.95, do_sample=True) + +# decode output tokens into text +print(tokenizer.decode(output[0][inputs.input_ids.shape[-1]:], skip_special_tokens=False)) +``` + + + +Expected output: + + + +```text Output + +The user is asking for the weather in Boston right now. There's a function called +get_current_weather that takes a city parameter. I need to call that with the city set to Boston. + + + + +Boston + + + +<|im_end|> +``` + + + +### Serving with vLLM + +Granite 4.2 is optimized for deployment with [vLLM](https://github.com/vllm-project/vllm). Use the custom `granite_thinking_parser` reasoning parser (included in each model repository, requires vLLM v0.20+) and the `qwen3_coder` tool-calling parser: + + + +```bash Serve +vllm serve ibm-granite/granite-4.2-30b \ + --served-model-name granite-4.2-30b \ + --dtype bfloat16 \ + --max-model-len 131072 \ + --reasoning-parser granite_thinking_parser \ + --reasoning-parser-plugin ./granite_thinking_parser.py \ + --tool-call-parser qwen3_coder \ + --enable-auto-tool-choice +``` + + + +The model then exposes an OpenAI-compatible API on `http://localhost:8000/v1`, which integrates with popular agentic coding harnesses such as OpenCode, Pi, and OpenHands out of the box. diff --git a/sidebars.ts b/sidebars.ts index 1875eee..6c54a15 100644 --- a/sidebars.ts +++ b/sidebars.ts @@ -7,6 +7,7 @@ const sidebars: SidebarsConfig = { type: 'category', label: 'Models', items: [ + 'models/granite4-2', 'models/granite4-1', 'models/granite', 'models/docling', diff --git a/src/pages/index.tsx b/src/pages/index.tsx index ff0b0ea..5fa5698 100644 --- a/src/pages/index.tsx +++ b/src/pages/index.tsx @@ -4,5 +4,5 @@ import {Redirect} from '@docusaurus/router'; import useBaseUrl from '@docusaurus/useBaseUrl'; export default function Home(): React.ReactElement { - return ; + return ; } From 5e522ffa8b38c349313b09fb6b01487cd2c64f4e Mon Sep 17 00:00:00 2001 From: serjikibm Date: Fri, 21 Aug 2026 14:45:43 -0400 Subject: [PATCH 2/6] add url updates to default 4.2 Signed-off-by: serjikibm --- docusaurus.config.ts | 5 ++++- granite/docs/run/granite-with-vllm-containerized.mdx | 2 +- granite/docs/use-cases/docling-rag.mdx | 2 +- sidebars.ts | 2 +- 4 files changed, 7 insertions(+), 4 deletions(-) diff --git a/docusaurus.config.ts b/docusaurus.config.ts index fbb0248..b96afc3 100644 --- a/docusaurus.config.ts +++ b/docusaurus.config.ts @@ -76,7 +76,10 @@ const config: Config = { '@docusaurus/plugin-client-redirects', { // Pre-wired empty: add entries here if any URLs change after the IBM.com cutover. - redirects: [], + redirects: [ + // The legacy /models/granite URL always lands on the latest generation. + {from: '/models/granite', to: '/models/granite4-2'}, + ], } satisfies RedirectOptions, ], [ diff --git a/granite/docs/run/granite-with-vllm-containerized.mdx b/granite/docs/run/granite-with-vllm-containerized.mdx index 608aa7c..ebec700 100644 --- a/granite/docs/run/granite-with-vllm-containerized.mdx +++ b/granite/docs/run/granite-with-vllm-containerized.mdx @@ -69,6 +69,6 @@ Now run the container with the added parameters: docker run --runtime nvidia --gpus all -v ~/.cache/huggingface:/root/.cache/huggingface -p 8000:8000 vllm/vllm-openai:latest --model ibm-granite/granite-4.0-h-small --tool-call-parser granite4 --enable-auto-tool-choice ``` -Once the container is up, you can start running requests using the OpenAI API. Refer to the documentation on OpenAI API [tool calling](/models/granite#tool-calling) for examples. +Once the container is up, you can start running requests using the OpenAI API. Refer to the documentation on OpenAI API [tool calling](/models/granite4-0#tool-calling) for examples. To run vLLM with the Granite 3 models and tool calling, use the additional parameters specified in the vLLM documentation [here](https://docs.vllm.ai/en/stable/features/tool_calling/#ibm-granite) as part of the `docker run` command share in Section 2. diff --git a/granite/docs/use-cases/docling-rag.mdx b/granite/docs/use-cases/docling-rag.mdx index d79d1ca..73da0bd 100644 --- a/granite/docs/use-cases/docling-rag.mdx +++ b/granite/docs/use-cases/docling-rag.mdx @@ -6,7 +6,7 @@ sidebar_custom_props: icon: "magnifying-glass" --- -In this tutorial, you will create an AI-powered document retrieval system with [Docling](https://github.com/DS4SD/docling), [LangChain](https://github.com/langchain-ai/langchain), and [Granite 3.1](/models/granite). The tutorial is designed to enable you to gain proficiency in document processing and chunking, integrate vector databases to enhance retrieval capabilities, and utilize RAG to perform efficient and accurate data retrieval for real-world applications. +In this tutorial, you will create an AI-powered document retrieval system with [Docling](https://github.com/DS4SD/docling), [LangChain](https://github.com/langchain-ai/langchain), and [Granite 3.1](/models/granite4-0). The tutorial is designed to enable you to gain proficiency in document processing and chunking, integrate vector databases to enhance retrieval capabilities, and utilize RAG to perform efficient and accurate data retrieval for real-world applications. Date: Fri, 21 Aug 2026 15:09:09 -0400 Subject: [PATCH 3/6] add sunset banner Signed-off-by: serjikibm --- docusaurus.config.ts | 10 ++++++++++ src/css/custom.css | 11 +++++++++++ 2 files changed, 21 insertions(+) diff --git a/docusaurus.config.ts b/docusaurus.config.ts index b96afc3..ef0486a 100644 --- a/docusaurus.config.ts +++ b/docusaurus.config.ts @@ -102,6 +102,16 @@ const config: Config = { {name: 'keywords', content: 'IBM Granite, AI, foundation models, LLM'}, {name: 'description', content: 'IBM Granite documentation — models, serving guides, cookbooks'}, ], + announcementBar: { + // Bump this id if the message changes and you want dismissals reset + // (only relevant while isCloseable is true). + id: 'site-sunset-2026', + content: + '⚠️ This documentation site is no longer being updated. For the latest Granite documentation and models, see Hugging Face and GitHub.', + backgroundColor: '#fcf4d6', + textColor: '#1c1200', + isCloseable: false, + }, navbar: { title: '', logo: { diff --git a/src/css/custom.css b/src/css/custom.css index 803ca7e..ea63b3a 100644 --- a/src/css/custom.css +++ b/src/css/custom.css @@ -119,3 +119,14 @@ padding-left: 0.5rem; margin-left: -0.5rem; } + +/* Sunset announcement bar — ensure links stay readable on the amber background */ +div[class^='announcementBar_'] { + font-weight: 500; + border-bottom: 1px solid #e0c200; +} +div[class^='announcementBar_'] a { + color: inherit; + text-decoration: underline; + font-weight: 700; +} From 5210deb39847b5bbdc943cc8f10e66a0c7d854cf Mon Sep 17 00:00:00 2001 From: serjikibm Date: Mon, 24 Aug 2026 13:17:33 -0400 Subject: [PATCH 4/6] make annoucement bar text and links bold to make them stand out Signed-off-by: serjikibm --- src/css/custom.css | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/css/custom.css b/src/css/custom.css index ea63b3a..07e8105 100644 --- a/src/css/custom.css +++ b/src/css/custom.css @@ -121,11 +121,11 @@ } /* Sunset announcement bar — ensure links stay readable on the amber background */ -div[class^='announcementBar_'] { +.theme-announcement-bar { font-weight: 500; border-bottom: 1px solid #e0c200; } -div[class^='announcementBar_'] a { +.theme-announcement-bar a { color: inherit; text-decoration: underline; font-weight: 700; From 1f740f43245e4a169e79a17deabacd1e86ca78ee Mon Sep 17 00:00:00 2001 From: serjikibm Date: Mon, 24 Aug 2026 14:44:41 -0400 Subject: [PATCH 5/6] add/merge updates from PR 77 Signed-off-by: serjikibm --- granite/docs/models/granite4-2.mdx | 62 +++++++++++++++++++++++++++--- granite/docs/models/guardian.mdx | 2 +- granite/docs/models/speech.mdx | 15 ++++---- 3 files changed, 65 insertions(+), 14 deletions(-) diff --git a/granite/docs/models/granite4-2.mdx b/granite/docs/models/granite4-2.mdx index 4e08354..c15797a 100644 --- a/granite/docs/models/granite4-2.mdx +++ b/granite/docs/models/granite4-2.mdx @@ -16,15 +16,15 @@ sidebar_custom_props: - Code examples, tools and documentation + Granite models and documentation ## Overview -**Granite 4.2** is a family of dense reasoning language models available in three sizes: 3B, 8B, and 30B parameters. Post-trained from the Granite 4.1 base models, the Granite 4.2 generation introduces native reasoning (thinking) capabilities, allowing models to perform step-by-step chain-of-thought reasoning before producing final answers. This significantly improves performance on complex math, coding, multi-step logic, and agentic tool-calling tasks. +**Granite 4.2** is a family of dense reasoning language models available in three sizes: 3B, 8B, and 30B parameters. Granite 4.2 introduces native reasoning (thinking) capabilities, allowing models to perform step-by-step chain-of-thought reasoning before producing final answers. This significantly improves performance on complex math, coding, multi-step logic, and agentic tool-calling tasks. ### Model Variants @@ -32,7 +32,7 @@ sidebar_custom_props: - **granite-4.2-8b**: Balanced reasoning model for general-purpose enterprise applications - **granite-4.2-30b**: Flagship reasoning model for complex reasoning and specialized tasks -All models natively support a 128K context window (with long-context extension to 512K) and are released under the Apache 2.0 license, enabling unrestricted commercial and academic use. +All models natively support a 128K context window (with long-context extension to 512K on the 30B model) and are released under the Apache 2.0 license with cryptographic signatures, ISO certification, and full transparency disclosures, enabling unrestricted commercial and academic use. ### Key Capabilities @@ -118,6 +118,35 @@ Granite 4.2 supports three thinking modes, selected via chat-template parameters | **Non-thinking** | `enable_thinking=False` | Direct answer with no reasoning overhead | | **Low-effort** | `enable_thinking=True, low_effort=True` | Brief reasoning for simpler queries | +#### Non-Thinking Mode + +Disable reasoning for a direct answer with no chain-of-thought overhead: + + + +```python Python +messages = [ + {"role": "user", "content": "What is the capital of France?"}, +] +text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True, enable_thinking=False) +inputs = tokenizer(text, return_tensors="pt").to(model.device) + +output = model.generate(**inputs, max_new_tokens=2048, temperature=1.0, top_p=0.95, do_sample=True) +print(tokenizer.decode(output[0][inputs.input_ids.shape[-1]:], skip_special_tokens=False)) +``` + + + +Expected output: + + + +```text Output +The capital of France is Paris.<|im_end|> +``` + + + ### Tool Calling Granite 4.2 supports tool calling with integrated reasoning — the model thinks about which tool to call and why before making the call. Define a list of tools using OpenAI's function definition schema: @@ -195,7 +224,10 @@ Boston ### Serving with vLLM -Granite 4.2 is optimized for deployment with [vLLM](https://github.com/vllm-project/vllm). Use the custom `granite_thinking_parser` reasoning parser (included in each model repository, requires vLLM v0.20+) and the `qwen3_coder` tool-calling parser: +Granite 4.2 is optimized for deployment with [vLLM](https://github.com/vllm-project/vllm) (v0.20+). + +> **Reasoning parser:** Use the custom `granite_thinking_parser`, available in each model's Hugging Face repository. The models also work with the built-in `nemotron_v3` parser, but `granite_thinking_parser` provides better formatting of reasoning output. +> **Tool calling parser:** Use `qwen3_coder`. @@ -213,3 +245,23 @@ vllm serve ibm-granite/granite-4.2-30b \ The model then exposes an OpenAI-compatible API on `http://localhost:8000/v1`, which integrates with popular agentic coding harnesses such as OpenCode, Pi, and OpenHands out of the box. + + + +```python Python +from openai import OpenAI + +client = OpenAI(base_url="http://localhost:8000/v1", api_key="unused") + +response = client.chat.completions.create( + model="granite-4.2-30b", + messages=[{"role": "user", "content": "Explain the Riemann hypothesis in simple terms."}], + temperature=1.0, + top_p=0.95, + max_tokens=8192, +) + +print(response.choices[0].message.content) +``` + + diff --git a/granite/docs/models/guardian.mdx b/granite/docs/models/guardian.mdx index b3cdf66..1f6e182 100644 --- a/granite/docs/models/guardian.mdx +++ b/granite/docs/models/guardian.mdx @@ -1,5 +1,5 @@ --- -title: "Granite Guardian 4.1" +title: "Granite Guardian" description: "Risk detection models and LoRA adapters for evaluating AI safety, RAG groundedness, and agentic function calling — with support for custom bring-your-own criteria (BYOC)." sidebar_custom_props: icon: "shield" diff --git a/granite/docs/models/speech.mdx b/granite/docs/models/speech.mdx index 3e6b754..7d5a56a 100644 --- a/granite/docs/models/speech.mdx +++ b/granite/docs/models/speech.mdx @@ -1,6 +1,6 @@ --- title: "Granite Speech" -description: "Compact multilingual models for automatic speech recognition (ASR) and translation (AST) across English, French, German, Spanish, Portuguese, and Japanese." +description: "Compact speech models for automatic speech recognition (ASR)." sidebar_custom_props: icon: "mic" --- @@ -14,9 +14,9 @@ sidebar_custom_props: View the full Granite Speech collection on Hugging Face Try Granite Speech in action @@ -38,21 +38,20 @@ sidebar_custom_props: ## Overview -The **Granite Speech 4.1** model family provides compact and efficient speech-language models for multilingual automatic speech recognition (ASR) and automatic speech translation (AST), supporting English, French, German, Spanish, Portuguese, and Japanese. All models are trained on 174,000 hours of audio from public corpora and tailored synthetic datasets. +The Granite Speech model family provides compact and efficient speech-language models for multilingual automatic speech recognition (ASR) and automatic speech translation (AST), supporting English, French, German, Spanish, Portuguese, and Japanese. ### Model Variants -The Granite Speech 4.1 suite includes three specialized variants: +The Granite Speech suite includes four specialized variants: +- **[granite-speech-5.0-470m-turboctc](https://huggingface.co/ibm-granite/granite-speech-5.0-470m-turboctc)**: compact English ASR model with very high inference speed that is well suited for deployment on laptops, smartphones and other edge devices - **[granite-speech-4.1-2b](https://huggingface.co/ibm-granite/granite-speech-4.1-2b)**: Balanced ASR and AST capabilities with improved punctuation and capitalization across all supported languages - **[granite-speech-4.1-2b-plus](https://huggingface.co/ibm-granite/granite-speech-4.1-2b-plus)**: Speech-to-text model with speaker-attributed ASR, timestamps, and keyword-prompted ASR for enhanced recognition of names, acronyms, and technical jargon - **[granite-speech-4.1-2b-nar](https://huggingface.co/ibm-granite/granite-speech-4.1-2b-nar)**: Non-autoregressive variant ([NLE architecture](https://arxiv.org/abs/2603.08397)) optimized for fast and accurate ASR with significantly lower latency ### Performance -Granite Speech 4.1 models deliver industry-leading performance on the [OpenASR Leaderboard](https://huggingface.co/spaces/hf-audio/open_asr_leaderboard): **granite-speech-4.1-2b ranks #1** for accuracy, while **granite-speech-4.1-2b-nar places #3** with exceptional speed through its non-autoregressive architecture. - -Granite Speech is released under the Apache 2.0 license, making it freely available for both research and commercial purposes, with full transparency into its training data. +Granite Speech models deliver industry-leading performance on the [OpenASR Leaderboard](https://huggingface.co/spaces/hf-audio/open_asr_leaderboard) and the FFASR Leaderboard. Granite Speech is released under the Apache 2.0 license, making it freely available for both research and commercial purposes, with full transparency into its training data. [Granite Speech Paper](https://arxiv.org/abs/2505.08699) From ebccc944b412e28a300461a96f62e12aa328b0be Mon Sep 17 00:00:00 2001 From: serjikibm Date: Mon, 24 Aug 2026 15:23:21 -0400 Subject: [PATCH 6/6] add new icon to 4.2 side nav item Signed-off-by: serjikibm --- granite/docs/models/granite4-2.mdx | 2 +- src/components/Icon.tsx | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/granite/docs/models/granite4-2.mdx b/granite/docs/models/granite4-2.mdx index c15797a..1807b9e 100644 --- a/granite/docs/models/granite4-2.mdx +++ b/granite/docs/models/granite4-2.mdx @@ -2,7 +2,7 @@ title: "Granite 4.2" description: "Dense reasoning language model family in 3B, 8B, and 30B sizes with built-in chain-of-thought thinking, flexible thinking modes, and reasoning-augmented tool calling." sidebar_custom_props: - icon: "sparkles" + icon: "brain" --- diff --git a/src/components/Icon.tsx b/src/components/Icon.tsx index a21ef08..9283df3 100644 --- a/src/components/Icon.tsx +++ b/src/components/Icon.tsx @@ -4,7 +4,7 @@ import useBaseUrl from '@docusaurus/useBaseUrl'; import {FontAwesomeIcon} from '@fortawesome/react-fontawesome'; import type {IconDefinition, SizeProp} from '@fortawesome/fontawesome-svg-core'; import { - faArrowRight, faBicycle, faBolt, faBook, faBox, faBriefcase, faBug, + faArrowRight, faBicycle, faBolt, faBook, faBox, faBrain, faBriefcase, faBug, faChartLine, faChurch, faCircleExclamation, faCircleQuestion, faCloud, faCode, faCookieBite, faCopy, faCube, faDesktop, faDownload, faEye, faFileCode, faImages, faLaptop, faMagnifyingGlass, faMicrophone, faNewspaper, @@ -26,6 +26,7 @@ const FA_MAP: Record = { 'bolt': faBolt, 'book': faBook, 'box': faBox, + 'brain': faBrain, 'briefcase': faBriefcase, 'chart-line': faChartLine, 'church': faChurch,