guell00/OBSIDIAN-9B-Coder

💎 OBSIDIAN-9B-Coder

Complete Code · Long Context · Interactive Software

OBSIDIAN-9B-Coder is a 9B-class coding model fine-tuned from Jackrong/Qwopus3.5-9B-Coder using the Coder Max Multilingual dataset.

The model is specialized in generating complete software implementations, with a strong focus on modern frontend development, interactive browser applications, Three.js, HTML5 Canvas, JavaScript, HTML/CSS, Python and general programming.

OBSIDIAN is designed around a simple objective:

Generate the implementation, not fragments of it.

⚡ Highlights

🧠 Overview

OBSIDIAN-9B-Coder was created to further specialize an already capable coding model toward implementation-heavy programming tasks.

Instead of focusing primarily on explanations surrounding code, the fine-tuning corpus heavily emphasizes generation of the actual implementation.

The model is particularly suited for:

• —Complete single-file web applications
• —HTML5
• —Modern CSS
• —JavaScript ES6+
• —Three.js
• —HTML5 Canvas
• —Interactive browser applications
• —Browser games
• —Graphical experiments
• —DOM manipulation
• —Animation loops
• —State management
• —Python
• —Algorithms
• —Multilingual programming instructions
• —Long-form code generation

🔥 Core Philosophy

USER REQUEST
      │
      ▼
┌──────────────────────┐
│  OBSIDIAN-9B-Coder   │
└──────────────────────┘
      │
      ▼
COMPLETE IMPLEMENTATION
      │
      ├── HTML
      ├── CSS
      ├── JavaScript
      ├── Three.js
      ├── Canvas
      └── Python

The training strategy emphasizes:

Less boilerplate explanation
           +
More actual implementation
           +
Complete long-form outputs
           =
OBSIDIAN

OBSIDIAN is fine-tuned to preserve long application structures including:

• —document layout;
• —styles;
• —application state;
• —event handlers;
• —rendering logic;
• —animation loops;
• —user interaction;
• —game logic;
• —DOM lifecycle;
• —complete closing structures.

🎮 Three.js Specialization

Three.js is one of the primary specialization targets of OBSIDIAN.

Training examples contain patterns involving:

• —Scene creation
• —Perspective cameras
• —Lighting
• —Meshes
• —Materials
• —Geometry
• —Animation loops
• —Keyboard input
• —Mouse interaction
• —Game mechanics
• —Collision logic
• —3D environments
• —Interactive simulations
• —Complete browser games
• —Single-file Three.js applications

The objective is not simply to teach isolated Three.js API calls.

The model is trained to connect the different components required to produce an actual working application.

For example:

Scene
  │
  ├── Camera
  ├── Renderer
  ├── Lighting
  ├── Objects
  │
  └── Materials
  │
  ├── Input
  ├── State
  ├── Game Logic
  └── Animation Loop

🌐 Frontend Generation

OBSIDIAN has strong exposure to complete frontend applications combining:

HTML
 │
 ├── CSS
 │
 └── JavaScript
       │
       ├── DOM
       ├── State
       ├── Events
       ├── Canvas
       ├── Three.js
       ├── Rendering
       └── Animation

A typical training target may contain an entire application:

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">

    <style>
        /* Complete interface */
    </style>
</head>

<body>

    <main>
        <!-- Complete application -->
    </main>

    <script>
        // Application state

        // Event handling

        // Rendering

        // Interaction

        // Animation loop
    </script>

</body>
</html>

The objective is to reduce common failure modes where coding models generate the beginning of an application but fail to correctly complete its architecture.

🌍 Multilingual Programming

OBSIDIAN was fine-tuned with programming instructions across 10 languages.

The goal is to make coding capability less dependent on the natural language used in the instruction.

A developer can therefore ask for implementations using prompts in multiple languages while still requesting code in the same programming ecosystem.

🗃️ Training Dataset

OBSIDIAN-9B-Coder was fine-tuned using Coder Max Multilingual.

Dataset:

guell00/Coder-max

Coder Max is a conversational supervised fine-tuning dataset focused heavily on code generation.

The corpus was designed around complete implementations rather than heavily truncated programming responses.

Dataset Characteristics

📊 Coder Max Scale

Coder Max is distributed in multiple incremental variants.

The larger variants contain the content represented by the smaller variants, allowing different training scales without requiring manual concatenation.

🧹 Dataset Curation

Coder Max was built with a code-oriented preprocessing pipeline.

Important characteristics include:

Code Density

More than 95% of the larger corpus variants consist of code-oriented content.

Python Syntax Validation

Python blocks were structurally checked during preprocessing.

Invalid or corrupted samples could therefore be removed before training.

Complete Code Preservation

Long HTML, CSS and JavaScript applications are preserved rather than intentionally truncated.

This is especially important for teaching:

• —closing tags;
• —application state;
• —complete functions;
• —event listeners;
• —rendering loops;
• —lifecycle logic.

Data Sanitization

The preprocessing pipeline targets removal of artifacts such as:

• —credentials;
• —API keys;
• —local IP addresses;
• —runtime artifacts.

Provenance

Dataset records include SHA-256-based provenance metadata.

🧪 Fine-Tuning

OBSIDIAN-9B-Coder was produced using supervised fine-tuning with LoRA.

Training configuration:

Training method          LoRA
Precision                BF16
LoRA rank                16
LoRA alpha               32
LoRA dropout             0
Context target           32,768
Trainer                  Unsloth
Optimizer                AdamW BNB 8-bit
Scheduler                Cosine
Response-only training   Enabled

LoRA target modules:

q_proj
k_proj
v_proj
o_proj
gate_proj
up_proj
down_proj

🧬 Training Strategy

The model was trained using a code-heavy SFT corpus designed around long-form completions.

Important characteristics include:

• —long HTML responses;
• —complete application generation;
• —high-value specialization examples;
• —multilingual prompt variants;
• —frontend-oriented training;
• —Three.js exposure;
• —Canvas exposure;
• —JavaScript-heavy examples;
• —assistant-response-only loss.

Some repetitions in the source dataset may be intentional.

Selected programming concepts and application patterns can be repeated to reinforce specific behaviors and specialization targets.

📦 GGUF

OBSIDIAN-9B-Coder is distributed in GGUF format for efficient local inference.

Available quantizations include:

⚖️ Quantization Guide

              QUALITY
                 ▲
                 │
Q8_0      ████████████████████
Q6_K      ██████████████████
Q5_K_M    █████████████████
Q4_K_M    ███████████████
Q3_K_M    ████████████
                 │
                 └──────────────► LOWER MEMORY

Q8_0

Use when preserving model fidelity is more important than memory consumption.

Q6_K

High-quality option with lower requirements than Q8_0.

Q5KM

Strong compromise between model fidelity and memory requirements.

Q4KM

Recommended starting point for most local deployments.

Q3KM

Designed for systems where memory consumption is the primary constraint.

For coding workloads, Q4_K_M and Q5_K_M are good starting points.

🚀 llama.cpp

For compatible text inference:

llama-cli -hf guell00/OBSIDIAN-9B-Coder --jinja

For compatible multimodal inference:

llama-mtmd-cli -hf guell00/OBSIDIAN-9B-Coder --jinja

The exact command and available features depend on the installed llama.cpp version and selected GGUF files.

💻 Example Prompts

Three.js Game

Create a complete Three.js game inside a single HTML file.

Include:

- responsive rendering;
- perspective camera;
- dynamic lighting;
- keyboard controls;
- collision logic;
- score system;
- restart functionality;
- animation loop.

Return the complete HTML file.

Frontend Application

Create a complete responsive web application using HTML,
CSS and vanilla JavaScript.

The application must include:

- modern interface;
- internal state;
- animations;
- user interaction;
- responsive design.

Return a single complete HTML file.

Portuguese

Crie uma aplicação web completa usando HTML, CSS e JavaScript.

A aplicação deve possuir uma interface moderna, animações,
estado interno e interação com o usuário.

Retorne o arquivo HTML completo.

Canvas

Build a complete interactive particle simulation using the
HTML5 Canvas API.

Include mouse interaction, animation, responsive resizing
and performance-conscious rendering.

Python

Implement a complete Python solution for the following problem.

Explain the algorithm briefly and return working code.

🎛️ Generation Settings

Coding tasks generally benefit from conservative sampling.

A reasonable starting point:

temperature: 0.2
top_p: 0.9

For more creative frontend generation:

temperature: 0.5 - 0.7
top_p: 0.9 - 0.95

These values are starting points rather than guaranteed optimal settings.

Generation parameters should be benchmarked for the target workload.

🎯 Intended Use

OBSIDIAN-9B-Coder is intended for:

• —Coding assistants
• —Frontend code generation
• —HTML/CSS/JavaScript generation
• —Three.js applications
• —Browser games
• —Canvas applications
• —Interactive interfaces
• —Python programming
• —Programming experiments
• —Multilingual coding assistants
• —Local coding models
• —Research into code-specialized fine-tuning

📏 Evaluation

Executable evaluation is strongly recommended for coding models.

A useful evaluation pipeline is:

PROMPT
  │
  ▼
GENERATE
  │
  ▼
PARSE
  │
  ▼
EXECUTE
  │
  ▼
INSPECT
  │
  ▼
TEST

Useful evaluation categories include:

• —HTML completeness
• —CSS validity
• —JavaScript syntax
• —JavaScript runtime behavior
• —Three.js initialization
• —Rendering-loop correctness
• —DOM interaction
• —Canvas rendering
• —Python syntax
• —Algorithmic correctness
• —Long-response completion
• —Multilingual instruction following

For code-generation models, executable correctness is generally more informative than text similarity alone.

⚠️ Limitations

OBSIDIAN-9B-Coder is a generative model.

Generated code can contain:

• —logical errors;
• —security vulnerabilities;
• —hallucinated APIs;
• —outdated library usage;
• —incomplete edge-case handling;
• —incorrect assumptions;
• —dependency incompatibilities.

Generated applications should be inspected and tested before production deployment.

Long context capacity also does not guarantee perfect reasoning or perfect retention across every token of a long prompt.

🧬 Model Lineage

OBSIDIAN-9B-Coder was not trained from scratch.

Its lineage is:

Qwen3.5 family
       │
       ▼
Jackrong/Qwopus3.5-9B-Coder
       │
       ▼
Coder Max Multilingual
       │
       ▼
LoRA Supervised Fine-Tuning
       │
       ▼
OBSIDIAN-9B-Coder
       │
       ▼
GGUF Quantizations

OBSIDIAN therefore inherits substantial pretrained and coding capabilities from its base model while adding specialization through Coder Max.

📚 Training Sources

Base Model

OBSIDIAN-9B-Coder was fine-tuned from:

Jackrong/Qwopus3.5-9B-Coder

Hugging Face:

https://huggingface.co/Jackrong/Qwopus3.5-9B-Coder

The Jackrong model is itself a coding-focused derivative of the Qwen3.5 model family and provides the underlying pretrained and coding capabilities used as the starting point for OBSIDIAN.

Fine-Tuning Dataset

The dataset used for the OBSIDIAN fine-tuning stage was:

Coder Max Multilingual

Author: guell00

Hugging Face:

https://huggingface.co/datasets/guell00/Coder-max

Coder Max provides the additional specialization toward:

• —complete code generation;
• —HTML/CSS/JavaScript;
• —Three.js;
• —Canvas;
• —Python;
• —interactive applications;
• —long-form implementations;
• —multilingual programming instructions.

🏗️ Training Stack

Qwen3.5 Model Family
        │
        ▼
Jackrong/Qwopus3.5-9B-Coder
        │
        │  Base model
        ▼
Coder Max Multilingual
guell00/Coder-max
        │
        │  Code-focused SFT data
        ▼
LoRA + SFT
Unsloth
        │
        ▼
OBSIDIAN-9B-Coder
        │
        ▼
GGUF
        │
        ├── Q3_K_M
        ├── Q4_K_M
        ├── Q5_K_M
        ├── Q6_K
        └── Q8_0

🙏 Credits

OBSIDIAN-9B-Coder builds upon work from the open-source model ecosystem.

Qwen

For the underlying Qwen model family and architecture.

Jackrong

For Qwopus3.5-9B-Coder, used as the direct base model for this fine-tuning.

Unsloth

For the efficient fine-tuning and model conversion tooling used during training.

guell00

For:

• —Coder Max Multilingual
• —OBSIDIAN fine-tuning
• —dataset preparation
• —model specialization
• —GGUF release

💎 OBSIDIAN-9B-Coder

Base
  Jackrong/Qwopus3.5-9B-Coder

        +

Dataset
  guell00/Coder-max

        +

Fine-Tuning
  LoRA SFT / Unsloth

        =

  OBSIDIAN-9B-Coder

9B · 32K Training Context · Three.js · JavaScript · HTML · CSS · Canvas · Python · Multilingual

OBSIDIAN-9B-Coder — specialized for complete code generation.