Nemotron-3.5-Bolt-E4B for ComfyUI

NVIDIA-Nemotron-3.5-Bolt-E4B, NVIDIA's post-trained Gemma-4-E4B-it, repackaged as ComfyUI text-encoder files. Nemotron-Bolt uses the Gemma 4 E4B architecture, so ComfyUI's own Gemma 4 support loads it with no custom nodes. You need ComfyUI v0.21.0 or newer.

There is nothing to configure. ComfyUI recognises the file as Gemma 4 E4B from its weights. It then uses its built-in Gemma 4 chat template, the tokenizer embedded in the file, and the stop tokens. Nemotron's own chat template renders exactly the same.

File	Size	Notes
text_encoders/nemotron_3.5_bolt_e4b_bf16.safetensors	16.0 GB	the release weights, unchanged
text_encoders/nemotron_3.5_bolt_e4b_int8_convrot.safetensors	8.1 GB	int8 + ConvRot, 0.82% mean / 1.19% max weight error

Put the file in models/text_encoders and load it with Load CLIP. Then use Generate Text:

• Thinking: toggle thinking on or off.
• Template: leave use_default_template on.
• Short, spoken-style replies: NVIDIA's conversational_mode is a system prompt. Pass this into system_prompt: "You are having a spoken conversation with the user. Respond as briefly as possible while still addressing their questions fully."
• Sampling: the recommended settings are temperature 1.0 and top_p 0.95.

The same file also works anywhere ComfyUI takes a Gemma 4 E4B text encoder. Image and audio inputs load too, because the vision and audio towers are included. NVIDIA tuned and evaluated the model on text only, though.

Uncensored LoRA

File	Size	Notes
loras/nemotron_3.5_bolt_e4b_uncensored_lora.safetensors	3.5 MB	AtomicChat's refusal-direction edit, as a ComfyUI LoRA

This is AtomicChat's Nemotron-3.5-Bolt-E4B Uncensored LoRA, NVIDIA-Nemotron-3.5-Bolt-E4B-Uncensored-LoRA.gguf, converted from llama.cpp GGUF to ComfyUI's LoRA format. All credit for the edit goes to AtomicChat. They found the refusal direction, computed the edit through Gemma 4's norms, and evaluated it. Their model card has the method, the numbers and the limitations. The method follows Arditi et al., Refusal in Language Models Is Mediated by a Single Direction (2024). The conversion only renames keys; the weights are unchanged.

Put the file in models/loras. The LoRA patches the text encoder only, so apply it to the CLIP from Load CLIP (either file above):

• In a graph that also has a diffusion model, use the core Load LoRA node and set strength_model to 0.
• In a text-only graph, core Load LoRA won't work because it needs a MODEL input. Use a loader where the model is optional, such as rgthree's Power Lora Loader, and connect only the CLIP.

Then use Generate Text as usual.

• Strength 1.0 is AtomicChat's recommended setting. They built the adapter for scale 1.25 (--lora-scaled … 1.25 in llama.cpp). That 1.25 is baked into the file's alpha, so strength 1.0 in ComfyUI equals 1.25 in llama.cpp.
• What it patches: rank 1, 126 matrices. In each of the 42 blocks it patches self_attn.o_proj, mlp.down_proj and per_layer_projection, the three writes into the residual stream. The keys are kohya-style lora_te_layers_<n>_<module>.

The edit removes the model's learned refusal behaviour, so it will answer requests the original declines. AtomicChat measured a small quality cost: MMLU fell from 68.50% to 67.85%, and KLD on neutral text was 0.159. The edit does not make the output safe, correct or lawful.

Checked in ComfyUI (test_lora.py), on both text-encoder files:

• Keys: all 126 keys bind, with no "lora key not loaded" warnings. The shapes match the base weights, including the wider o_proj of the global-attention layers.
• The edit lands: AtomicChat's edit is W' = W − 1.25 · r′r′ᵀW, so each matrix should keep a quarter of what it writes along r′. ComfyUI's patched weights keep 0.249–0.250 (bf16) and 0.249–0.252 (int8 ConvRot, after ComfyUI requantizes the patched weight).
• Behaviour (greedy, thinking off): asked for hotwiring instructions, the base model opens with "I cannot provide…" on both files. With the LoRA it no longer refuses. On bf16 it starts answering, with safety caveats. On int8 it lists caveats and alternatives instead. A harmless how-to and a math question (391) give the same answers with and without the LoRA.

Verification

• Layout: each file's tensor names, shapes and dtypes are identical to Comfy-Org's gemma4_e4b_it_bf16 / gemma4_e4b_it_int8_convrot. The int8 file quantizes the same 622 linears and 2 embedding tables that Comfy-Org's does.
• Tokenizer: byte-identical to stock Gemma 4. The stop tokens are the same.
• Chat template: Nemotron's chat_template.jinja renders the same strings as ComfyUI's built-in Gemma 4 template, with thinking on and off.
• Output: with greedy decoding in ComfyUI, bf16 and int8 give the same output on the test prompts. This covers a 474-token thinking trace.
• Speed (RTX 5090, one prompt at a time): bf16 68 tok/s, int8 29 tok/s. int8 saves VRAM, not time, for single-token decoding.

How it was made

The bf16 file is made in two steps:

• Renaming: it maps the HF keys to ComfyUI's Gemma 4 layout:
  • model.language_model. → model.
  • vision_tower → vision_model
  • audio_tower → audio_model
  • embed_vision / embed_audio → multi_modal_projector / audio_projector
• Merging: NVIDIA's release keeps the k/v projections of the 18 KV-shared layers (24–41) in a separate file, model-frozen-shared-kv.safetensors. Those layers reuse earlier layers' keys and values, so the weights are unused, but ComfyUI's module still declares them. The script merges them back and embeds tokenizer.json.

The int8 file uses comfy-model-tools' int8 + ConvRot recipe, streamed to disk.

Licence

The model is NVIDIA's, under the OpenMDW License 1.1. It is post-trained from Google Gemma 4 (Apache-2.0). This repo only repackages it.

The uncensored LoRA is AtomicChat's work, released under the same OpenMDW License 1.1. Its direction, edit and evaluation are by AtomicChat; this repo only converts its format with convert_lora.py.