Hydrogen-1.0 NVFP4

Hydrogen-1.0 NVFP4

A 4-bit NVFP4 build of Hydrogen-1.0, a 381B science and research assistant model from Deep Principle, based on GLM-5.3. It needs a multi-GPU NVIDIA Blackwell server and has a 1M token context.

Made by deep-principle on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: This is the NVFP4 quantized build of Hydrogen-1.0, a text model from Deep Principle that is based on GLM-5.3. It is meant to help with scientific questions, explain derivations and organize answers to open research problems. It has 381B parameters, a 1M token context and a 128K token output limit. The weights come to about 381 GB. The card says answers must be checked against each task's assumptions and evidence.

Who it suits: It suits research teams and infrastructure engineers who have a multi-GPU NVIDIA Blackwell server and want a large science assistant on their own hardware.

Industry | Who uses it | How they use it | Example
Chemistry | Computational chemists | Explore reaction networks with the model and outside tools | The maker's blog lists reaction-network exploration as a demonstration
Analytical science | Spectroscopy teams | Work through structure analysis | The blog lists NMR structure analysis
Research planning | Lab leads | Draft and refine experiment plans | The blog lists experimental planning

You can skip it if you have no multi-GPU Blackwell machine, since this build targets that runtime, and the team tested it only on 8x B300.

Where to use it:

• SGLang, which the team used for its tests
• NVIDIA Blackwell servers, such as the 8x B300 machine the card names
• Any client that speaks an OpenAI-style API to a server you run
• Windows, macOS or Linux with Python, to download the files

Use case | Who | What they get back
Science questions and derivations | Researchers | Written explanations that need expert review
Open-ended research problems | Research teams | Organized responses to check against the evidence
Long documents | Analysts | Room for up to 1M tokens of context, as the card states

How to set it up: You need a Blackwell server, a compatible runtime and a lot of storage.

• A compatible NVIDIA Blackwell runtime, which the team tested on 8x B300
• SGLang, installed in a version that supports this export format
• About 381 GB for the weights
• The config.json and hf_quant_config.json files kept next to the weights
• Python with the Hugging Face tools, to download the files

1. Install the Hugging Face tools with Python.
2. Download the repository files with the second command below.
3. Keep the tokenizer, chat template and config files together with the weights.
4. Start the SGLang server with the launch command.
5. Send requests from an OpenAI-style client.

pip install -U huggingface_hub
hf download deep-principle/Hydrogen-1.0-NVFP4

How to use it: The card gives one launch command for SGLang on 8 GPUs. It limits the deployed context to 262144 tokens, which is lower than the model's stated 1M. The server then answers under the name hydrogen-1.0.

python -m sglang.launch_server \
  --model-path deep-principle/Hydrogen-1.0-NVFP4 \
  --served-model-name hydrogen-1.0 \
  --tp 8 --trust-remote-code \
  --quantization modelopt_fp4 --kv-cache-dtype fp8_e4m3 \
  --reasoning-parser glm45 --tool-call-parser glm47 \
  --context-length 262144 --mem-fraction-static 0.85 \
  --chunked-prefill-size 16384 \
  --host 0.0.0.0 --port 8001

Tool | What it does
SGLang | Serves the checkpoint through an OpenAI-style API
NVIDIA ModelOpt | The tool the maker used to quantize the weights
openai Python package | Client that calls the running server
config.json | Holds the quantization settings, so keep it with the weights

Example: You start the server with the command above and send it a question about a reaction mechanism from an OpenAI-style client. The card stresses that this setup does not download or load weights for you, and that no hosted endpoint is implied.

For newcomers and experts: Think of it as a huge research assistant that has been compressed so it fits on a rack of GPUs. A first small try is to read the card's usage section before you plan the hardware.

The card says routed experts are stored in NVFP4 with calibrated activation scales, and the first three dense layers use FP8. The remaining parts stay in BF16: shared experts, attention, router and embeddings, plus the output head and the MTP layer. It also sets an FP8 KV cache. Use a runtime that supports this exact format.

Download the weights and config files
Start SGLang on a Blackwell server
Send a science question to the API
The model reasons and writes an answer
Check the answer against the evidence

Good to know: The repository holds one of three builds of the same model.

Title: Builds of Hydrogen-1.0
Version | Hardware
BF16, unquantized | Needs plenty of device and host memory
NVFP4, this one | NVIDIA Blackwell, tested on 8x B300
MXFP4 | AMD Instinct, tested on MI350X with ATOM

Title: Limits in the card
Limit | Value
Context length | 1M tokens
Maximum output length | 128K tokens
Context in the launch command | 262144 tokens

• Training: the data and methods behind the model are not published alongside the weights
• Review: outputs need scientific review, and the demos in the blog used outside tools
• License: MIT
• Cost to run: none named, but it needs a multi-GPU server
• Data it reaches: the files you download and the prompts you send to your own server
• Not for: laptops, machines without a Blackwell runtime, or results used without expert review

On Hugging Face, 13 November 2026

• Task: text generation
• Parameters: 381B
• Weights: about 381 GB in U8
• Formats: Safetensors
• Downloads in the last 30 days: 10,959
• Likes: 14
• License: mit
• Based on: deep-principle/Hydrogen-1.0
• Tags: safetensors, glm_moe_dsa, nvfp4, science, text-generation, conversational, 8-bit, modelopt

Links

• Model: https://huggingface.co/deep-principle/Hydrogen-1.0-NVFP4
• Files: https://huggingface.co/deep-principle/Hydrogen-1.0-NVFP4/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download deep-principle/Hydrogen-1.0-NVFP4

Then follow the usage in its model card. Nothing in this kit runs by itself.