Nexora-Vector-v0.1 · GGUF

Nexora-Vector-v0.1 GGUF is the official GGUF quantized release of Nexora-Vector-v0.1, published by Open4bits — the official quantization project under ArkAiLabs. Nexora-Vector is an experimental text-to-vector model that generates structured SVG graphics from natural language prompts. This GGUF release enables efficient local inference across a wide range of hardware via tools such as llama.cpp, Ollama, LM Studio, and Jan.

---

Table of Contents

• Overview
• Model Details
• Available Quantizations
• Capabilities
• Limitations
• Intended Use
• Architecture & Quantization
• Usage Recommendations
• Installation & Inference
• Original Model & Other Versions
• Evaluation
• Risks & Considerations
• Future Work
• Community & Support
• License
• Acknowledgements

---

Overview

This is the official GGUF quantized release of Nexora-Vector-v0.1, published by Open4bits — the official quantization project under ArkAiLabs. Multiple quantization levels are provided to suit different hardware configurations, from low-VRAM and CPU-only setups to higher-fidelity deployments.

The base model is a supervised fine-tuned variant of Qwen3-4B-Instruct, adapted specifically to generate structured vector graphics in SVG format from natural language instructions.

This release is in beta and is intended for research, experimentation, and early-stage design tooling. All outputs should be validated before use in any downstream pipeline.

---

Model Details

---

Available Quantizations

Recommendation: Q4_K_M is the best starting point for most users — it offers a strong balance between output quality and memory footprint.

---

Capabilities

Nexora-Vector-v0.1 is designed to translate textual instructions into structured SVG code. This GGUF release retains all capabilities of the original model while enabling flexible local inference across a wide range of hardware. The model is best suited for:

• Generating SVG markup for simple vector graphics
• Producing geometric shapes and basic illustrations
• Creating lightweight icons and minimal design assets
• Supporting rapid prototyping in vector-based design workflows
• Running fully locally with no internet connection required

Tip: The model performs best with concise, clearly scoped prompts focused on simple visual compositions.

---

Limitations

This is an early-stage beta release. Users should be aware of the following constraints:

• High hallucination rate — outputs may be invalid or non-renderable SVG
• Limited generalization — the small training dataset (~1,500 samples) affects output consistency
• Weak complex scene handling — highly detailed or multi-element prompts may produce poor results
• Manual correction required — outputs should be validated and post-processed before use
• Not production-ready — not suitable for safety-critical or automated pipelines
• Quantization quality trade-off — lower-bit quants (e.g. Q2_K) will show more degradation in output quality

---

Intended Use

✅ Supported Use Cases

• Academic and applied research in text-to-vector generation
• Experimental AI-assisted design systems running locally
• Educational exploration of structured output generation
• Lightweight SVG prototyping and ideation with low memory overhead
• Offline and air-gapped environments requiring fully local inference

❌ Out-of-Scope Use Cases

• Production-grade or commercial vector asset pipelines
• High-precision design deliverables without human validation
• Automated systems where SVG correctness is required without manual review

---

Architecture & Quantization

This release provides GGUF quantizations of the original Nexora-Vector-v0.1 weights, which are a supervised fine-tune of Qwen3-4B-Instruct.

Quantization Details

Original Training Configuration

Note: The relatively small dataset size may result in instability and limited generalization across diverse prompts. Improved dataset coverage is planned for future versions.

---

Usage Recommendations

To get the best results from this model:

1. Keep prompts simple and specific — avoid multi-scene or highly complex compositions
2. Validate all SVG outputs before rendering or integrating into any pipeline
3. Post-process outputs to correct syntax or structural issues
4. Use iterative prompting — refining prompts across multiple turns often yields better results
5. Expect imperfections — this is a beta model; treat outputs as drafts, not finals
6. Choose the right quant — use Q4_K_M for the best quality-to-size ratio; only use Q2_K if memory is severely constrained

---

Installation & Inference

llama.cpp

# Clone and build llama.cpp
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp && make

# Download a quantized file, e.g. Q4_K_M
huggingface-cli download Open4bits/nexora-vector-v0.1-GGUF \
  --include "*Q4_K_M*" --local-dir ./nexora-vector-gguf

# Run inference
./llama-cli \
  -m ./nexora-vector-gguf/nexora-vector-v0.1-Q4_K_M.gguf \
  -p "Generate an SVG of a simple red circle centered on a white background." \
  -n 1024

Ollama

# Create a Modelfile
cat > Modelfile <<EOF
FROM ./nexora-vector-v0.1-Q4_K_M.gguf
EOF

ollama create nexora-vector -f Modelfile
ollama run nexora-vector "Generate an SVG of a blue star."

LM Studio

1. Open LM Studio and go to the Search tab
2. Search for Open4bits/nexora-vector-v0.1-GGUF
3. Select your preferred quantization (recommended: Q4_K_M)
4. Click Download and load the model
5. Use the Chat or API tab to run inference

Python (via llama-cpp-python)

pip install llama-cpp-python

from llama_cpp import Llama

llm = Llama.from_pretrained(
    repo_id="Open4bits/nexora-vector-v0.1-GGUF",
    filename="*Q4_K_M*",
    n_ctx=2048,
)

output = llm(
    "Generate an SVG of a simple red circle centered on a white background.",
    max_tokens=1024,
)
print(output["choices"][0]["text"])

---

Original Model & Other Versions

---

Evaluation

Nexora-Vector-v0.1 has not yet undergone formal benchmark evaluation. Current assessment is qualitative, based on manual testing of SVG generation tasks.

Planned evaluation metrics for future releases include:

---

Risks & Considerations

Developers integrating this model should account for the following risks:

• Generation of malformed or non-functional SVG code
• Inconsistent instruction following across prompt variations
• Unpredictable outputs due to limited training data coverage
• Quality degradation at lower quantization levels (particularly Q2_K)

Recommendation: Implement downstream validation layers and SVG syntax checking before any rendering or integration.

---

Future Work

The following improvements are planned for upcoming versions of the Nexora Vector series:

• Expanded and more diverse training dataset
• Improved SVG syntax correctness and validity rates
• Reduced hallucination rates
• Enhanced natural language understanding for complex prompts
• Support for richer vector compositions and multi-element scenes
• Formal benchmark evaluation suite
• Updated GGUF releases aligned with future model versions

---

Community & Support

Join the community for updates and discussion:

💬 Join our Discord Server

---

License

This model is released under the Apache License 2.0.

You may use, modify, and distribute this model in accordance with the terms of the Apache 2.0 license. See the LICENSE file for full details, or refer to the official Apache 2.0 license text.

---

Acknowledgements

This is an official ArkAiLabs release, published under the Open4bits project — ArkAiLabs' dedicated initiative for quantized model releases. The GGUF weights are derived from Nexora-Vector-v0.1, which is itself built upon Qwen3-4B by the Qwen team. We thank the llama.cpp team and the open-source AI community for their continued contributions that make projects like this possible.

---

About Nexora & Open4bits

Nexora is an experimental AI initiative under ArkAiLabs, focused on building lightweight, practical, and creative AI systems for real-world applications. The Nexora Vector series represents our exploration into AI-assisted vector graphics generation.

Open4bits is ArkAiLabs' official project for quantized model releases, providing optimized variants of Nexora models for efficient local inference across different hardware platforms.