Aeonthic/OpenLumen-2-Pulsar

OpenLumen 2 Pulsar

OpenLumen 2 Pulsar is the open-weight, text-only FP16 release of the Lumen 2 Pulsar family.

Unlike the primary Lumen 2 Pulsar models, OpenLumen 2 Pulsar does not use Lumen QAT and does not include a vision encoder. It is distributed as a standard FP16 Transformers model, intended to provide a simple and broadly compatible version of the model for inference, research, experimentation, and further fine-tuning.

Some model weights are shared with Lumen 2 Pulsar, but OpenLumen 2 Pulsar should not be considered a bit-for-bit FP16 reconstruction of the quantized Lumen 2 Pulsar release.

Model Overview

Property	OpenLumen 2 Pulsar
Base architecture	Gemma 4 26B-A4B
Modality	Text only
Weight format	FP16
Lumen QAT	No
Vision	No
Model size	~48 GB
Framework	Transformers
Architecture	Mixture-of-Experts
License	Apache 2.0 / Gemma terms

OpenLumen 2 Pulsar deliberately prioritizes a conventional FP16 distribution rather than the aggressively optimized low-bit deployment formats used by other Lumen models.

Training

OpenLumen 2 Pulsar was trained and fine-tuned using aikar-engine, Aeonthic's open-source LLM training, Pruning, and inference engine:

https://github.com/DFveloper/aikar-engine

aikar-engine provides the training infrastructure used throughout the Lumen development pipeline, including support for model fine-tuning, quantization-aware training experiments, and other LLM optimization workflows.

The OpenLumen 2 Pulsar checkpoint released here is an FP16, non-QAT model, although the broader Lumen model family and training workflow also make use of aikar-engine's quantization and optimization capabilities.

Important: Quantization

OpenLumen 2 Pulsar is not QAT-trained.

Naively quantizing the FP16 checkpoint to very low-bit formats may cause substantial degradation. In particular, Q4_0 post-training quantization is currently known to severely degrade or break model behavior.

This is an important distinction between OpenLumen 2 Pulsar and Lumen 2 Pulsar: the latter uses Lumen's quantization-aware training pipeline, while OpenLumen 2 Pulsar does not.

For this reason, FP16 is currently the recommended format for reproducing the intended behavior of OpenLumen 2 Pulsar.

Other quantization methods and precisions may work, but they should be independently evaluated before deployment.

Memory Requirements

The FP16 checkpoint occupies approximately 48 GB.

Despite the Pulsar name and partial weight correspondence with Lumen 2 Pulsar, the unquantized OpenLumen release has memory requirements closer to Lumen 2 Magnetic than to the optimized Lumen 2 Pulsar deployment.

Actual runtime memory usage depends on the inference backend, context length, KV cache configuration, batching, and device placement.

Multi-GPU inference or CPU offloading may therefore be necessary on systems without sufficient accelerator memory.

Text-Only Release

The original Gemma 4 architecture supports multimodal inputs. OpenLumen 2 Pulsar, however, is intentionally released as a text-only model.

Vision functionality is not included or supported by this checkpoint.

This is intentional rather than a packaging omission.

Usage

Install recent versions of the required libraries:

pip install -U transformers torch accelerate

Example usage:

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

MODEL_ID = "Aeonthic/OpenLumen-2-Pulsar"

tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)

model = AutoModelForCausalLM.from_pretrained(
    MODEL_ID,
    torch_dtype=torch.float16,
    device_map="auto",
)

messages = [
    {
        "role": "user",
        "content": "Explain speculative decoding in simple terms."
    }
]

inputs = tokenizer.apply_chat_template(
    messages,
    tokenize=True,
    add_generation_prompt=True,
    return_tensors="pt",
).to(model.device)

with torch.inference_mode():
    outputs = model.generate(
        inputs,
        max_new_tokens=512,
    )

response = tokenizer.decode(
    outputs[0][inputs.shape[-1]:],
    skip_special_tokens=True,
)

print(response)

Depending on the final Transformers integration and model configuration, loading APIs may differ between versions. Use a recent Transformers release.

Training Data

The training dataset used to produce OpenLumen 2 Pulsar is not publicly released.

The model weights are provided for use under the applicable license, but the underlying Lumen training and alignment datasets remain proprietary.

No release of the training dataset is currently planned.

Relationship to Lumen 2 Pulsar

OpenLumen 2 Pulsar and Lumen 2 Pulsar belong to the same model family, but they target different deployment goals.

Lumen 2 Pulsar focuses on efficient deployment using Lumen's quantization-aware training and optimization pipeline.

OpenLumen 2 Pulsar instead provides a conventional FP16 checkpoint with broad compatibility and without requiring the Lumen QAT stack.

Some weights between the two models are identical, but their numerical representation, deployment characteristics, memory requirements, and low-bit behavior differ substantially.

In short:

OpenLumen 2 Pulsar is the FP16, text-only, non-QAT member of the Lumen 2 Pulsar family.

Base Model

OpenLumen 2 Pulsar is based on:

Google Gemma 4 26B-A4B

Gemma 4 is developed by Google DeepMind. Please refer to the original Gemma documentation and model card for architecture details, usage conditions, and licensing information.

License

OpenLumen 2 Pulsar is released under the Apache License 2.0, subject to the applicable Gemma terms.

Please review the Gemma license and usage terms before redistribution or deployment.

Citation

OpenLumen 2 Pulsar is derived from Gemma 4. When using this model in academic work, please cite the original Gemma 4 Technical Report:

@misc{gemmateam2026gemma4,
      title={Gemma 4 Technical Report},
      author={Gemma Team},
      year={2026},
      eprint={2607.02770},
      archivePrefix={arXiv},
      primaryClass={cs.CL},
      url={https://arxiv.org/abs/2607.02770},
}

Disclaimer

OpenLumen 2 Pulsar is provided as an open-weight research and development release. Model outputs may be inaccurate, biased, or otherwise unsuitable for a particular application.

Users are responsible for evaluating the model for their intended use case and for complying with applicable licenses, laws, and regulations.