Update README.md

README.md

@@ -14,314 +14,354 @@ pipeline_tag: text-generation
 tags:
 - code
 - coding
+- coder
+- qwen
+- qwen3.5
 - gguf
 - unsloth
 - lora
+- sft
 - html
+- css
 - javascript
 - threejs
+- canvas
 - python
 - multilingual
 ---
 
-# OBSIDIAN-9B-Coder
+# 💎 OBSIDIAN-9B-Coder
 
-**OBSIDIAN-9B-Coder** is a 9B coding model fine-tuned on the **Coder Max Multilingual** dataset.
+> **Complete Code · Long Context · Interactive Software**
 
-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 and general programming.
+**OBSIDIAN-9B-Coder** is a 9B-class coding model fine-tuned from **Jackrong/Qwopus3.5-9B-Coder** using the **Coder Max Multilingual** dataset.
 
-> **Complete code. Long context. Interactive software.**
+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
+---
 
-* **9B parameter-class coding model**
-* **32K training context**
-* **Multilingual coding support**
-* **Three.js specialization**
-* **Complete HTML/CSS/JavaScript applications**
-* **Canvas and browser graphics**
-* **Python and algorithmic code**
-* **LoRA supervised fine-tuning**
-* **GGUF quantizations available**
-* **Fine-tuned with Unsloth**
+## ⚡ Highlights
+
+| Feature | OBSIDIAN-9B-Coder |
+|---|---|
+| Model Class | 9B |
+| Training Context | 32K |
+| Training Method | LoRA SFT |
+| Training Framework | Unsloth |
+| Languages | 10 |
+| Primary Focus | Code Generation |
+| Frontend | Strong specialization |
+| Three.js | Strong specialization |
+| Canvas | Strong specialization |
+| JavaScript | Strong specialization |
+| Python | Supported |
+| Distribution | GGUF |
 
 ---
 
-# Overview
+# 🧠 Overview
 
-OBSIDIAN-9B-Coder was created to specialize a Qwen-based coding model toward **implementation-heavy programming tasks**.
+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 the generation of the actual implementation.
+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 and modern CSS
-* JavaScript ES6+
-* Three.js
-* HTML5 Canvas
-* Interactive browser applications
-* Games and graphical experiments
-* DOM manipulation
-* Animation loops
-* State management
-* Python
-* Algorithmic programming
-* Multilingual programming instructions
+- 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
+# 🔥 Core Philosophy
 
 ```text
 USER REQUEST
-     ↓
-OBSIDIAN-9B-Coder
-     ↓
+      │
+      ▼
+┌──────────────────────┐
+│  OBSIDIAN-9B-Coder   │
+└──────────────────────┘
+      │
+      ▼
 COMPLETE IMPLEMENTATION
-     ↓
-HTML / CSS / JavaScript / Three.js / Python
+      │
+      ├── HTML
+      ├── CSS
+      ├── JavaScript
+      ├── Three.js
+      ├── Canvas
+      └── Python
 ```
 
-The goal is simple:
+The training strategy emphasizes:
 
-> **Less explanation. More implementation. Complete outputs.**
+```text
+Less boilerplate explanation
+           +
+More actual implementation
+           +
+Complete long-form outputs
+           =
+OBSIDIAN
+```
 
-OBSIDIAN is fine-tuned to preserve long application structure, including:
+OBSIDIAN is fine-tuned to preserve long application structures including:
 
-* document layout;
-* event handlers;
-* state;
-* rendering loops;
-* interaction logic;
-* animation;
-* closing tags;
-* frontend lifecycle.
+- document layout;
+- styles;
+- application state;
+- event handlers;
+- rendering logic;
+- animation loops;
+- user interaction;
+- game logic;
+- DOM lifecycle;
+- complete closing structures.
 
 ---
 
-# GGUF
+# 🎮 Three.js Specialization
 
-This model was fine-tuned and converted to **GGUF** format using **Unsloth**.
-
-The repository contains multiple quantizations so users can select the appropriate balance between model size, memory usage and output quality.
+Three.js is one of the primary specialization targets of OBSIDIAN.
 
-## Available Model Files
+Training examples contain patterns involving:
 
-| File                                  | Quantization | Notes                             |
-| ------------------------------------- | ------------ | --------------------------------- |
-| `Qwopus3.5-9B-Coder.Q8_0.gguf`        | Q8_0         | Highest-quality quantized version |
-| `Qwopus3.5-9B-Coder.Q6_K.gguf`        | Q6_K         | High quality with reduced size    |
-| `Qwopus3.5-9B-Coder.Q5_K_M.gguf`      | Q5_K_M       | Strong quality/size balance       |
-| `Qwopus3.5-9B-Coder.Q4_K_M.gguf`      | Q4_K_M       | Recommended balance for local use |
-| `Qwopus3.5-9B-Coder.Q3_K_M.gguf`      | Q3_K_M       | Lower memory requirement          |
-| `Qwopus3.5-9B-Coder.BF16-mmproj.gguf` | BF16 mmproj  | Multimodal projector artifact     |
+- 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.
 
-# llama.cpp
+The model is trained to connect the different components required to produce an actual working application.
 
-For compatible text-generation configurations:
+For example:
 
-```bash
-llama-cli -hf guell00/OBSIDIAN-9B-Coder --jinja
+```text
+Scene
+  │
+  ├── Camera
+  ├── Renderer
+  ├── Lighting
+  ├── Objects
+  │
+  └── Materials
+  │
+  ├── Input
+  ├── State
+  ├── Game Logic
+  └── Animation Loop
 ```
 
-For compatible multimodal configurations:
+---
 
-```bash
-llama-mtmd-cli -hf guell00/OBSIDIAN-9B-Coder --jinja
+# 🌐 Frontend Generation
+
+OBSIDIAN has strong exposure to complete frontend applications combining:
+
+```text
+HTML
+ │
+ ├── CSS
+ │
+ └── JavaScript
+       │
+       ├── DOM
+       ├── State
+       ├── Events
+       ├── Canvas
+       ├── Three.js
+       ├── Rendering
+       └── Animation
 ```
 
-Depending on your environment and the files selected automatically by `llama.cpp`, you may want to explicitly choose a GGUF quantization.
+A typical training target may contain an entire application:
 
----
+```html
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
 
-# Quantization Guide
+    <style>
+        /* Complete interface */
+    </style>
+</head>
 
-## Q8_0
+<body>
 
-Best option when memory usage is less important and you want to preserve as much quality as practical in GGUF form.
+    <main>
+        <!-- Complete application -->
+    </main>
 
-## Q6_K
+    <script>
+        // Application state
 
-High-quality quantization with lower memory requirements than Q8.
+        // Event handling
 
-## Q5_K_M
+        // Rendering
 
-A strong balance between quality and size.
+        // Interaction
 
-Good choice for machines with moderate RAM/VRAM.
+        // Animation loop
+    </script>
 
-## Q4_K_M
+</body>
+</html>
+```
 
-Recommended general-purpose quantization.
+The objective is to reduce common failure modes where coding models generate the beginning of an application but fail to correctly complete its architecture.
 
-It usually offers a useful balance between:
+---
 
-* memory usage;
-* inference speed;
-* output quality.
+# 🌍 Multilingual Programming
 
-## Q3_K_M
+OBSIDIAN was fine-tuned with programming instructions across **10 languages**.
+
+| Language | Code |
+|---|---|
+| Português | `pt` |
+| English | `en` |
+| Español | `es` |
+| Français | `fr` |
+| Deutsch | `de` |
+| Italiano | `it` |
+| 日本語 | `ja` |
+| 简体中文 | `zh` |
+| Русский | `ru` |
+| Türkçe | `tr` |
 
-Smaller memory footprint.
+The goal is to make coding capability less dependent on the natural language used in the instruction.
 
-Useful when hardware is constrained, at the cost of some model fidelity.
+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:
+# 🗃️ Training Dataset
 
-**Coder Max Multilingual**
+OBSIDIAN-9B-Coder was fine-tuned using **Coder Max Multilingual**.
 
-Repository:
+**Dataset:**
 
 `guell00/Coder-max`
 
 Coder Max is a conversational supervised fine-tuning dataset focused heavily on code generation.
 
-The corpus was designed to contain **complete implementations instead of heavily truncated programming answers**.
+The corpus was designed around **complete implementations rather than heavily truncated programming responses**.
 
 ## Dataset Characteristics
 
-| Characteristic          | Description             |
-| ----------------------- | ----------------------- |
-| Format                  | JSONL                   |
-| Structure               | Conversational messages |
-| Training type           | Supervised Fine-Tuning  |
-| Languages               | 10                      |
-| Main content            | Programming             |
-| Code density            | ~95%+                   |
-| Frontend focus          | Strong                  |
-| Three.js specialization | Strong                  |
-| Long code outputs       | Preserved               |
+| Characteristic | Description |
+|---|---|
+| Format | JSONL |
+| Structure | Conversational messages |
+| Training Type | Supervised Fine-Tuning |
+| Languages | 10 |
+| Main Content | Programming |
+| Code Density | ~95%+ |
+| Frontend Focus | Strong |
+| Three.js Specialization | Strong |
+| Long Code Outputs | Preserved |
 
 ---
 
-# Dataset Scale
+# 📊 Coder Max Scale
 
-Coder Max is distributed in incremental variants.
+Coder Max is distributed in multiple incremental variants.
 
-| Variant     |   Physical Size | Records | Messages | Code Density |
-| ----------- | --------------: | ------: | -------: | -----------: |
-| `001MB`     |     3,739,874 B |     109 |      220 |       99.08% |
-| `010MB`     |    12,709,008 B |     969 |    2,012 |       96.18% |
-| `100MB`     |   102,679,666 B |   9,790 |   20,396 |       95.84% |
-| `300MB`     |   302,689,973 B |  29,233 |   60,916 |       95.83% |
-| `500MB`     |   502,678,782 B |  48,676 |  101,442 |       95.82% |
-| `600MB`     |   602,666,385 B |  58,466 |  121,848 |       95.82% |
-| `001GB`     | 1,002,677,454 B |  97,499 |  203,200 |       95.82% |
-| `total_4GB` | 4,002,669,404 B | 390,302 |  813,452 |       95.81% |
+| Variant | Physical Size | Records | Messages | Code Density |
+|---|---:|---:|---:|---:|
+| `001MB` | 3,739,874 B | 109 | 220 | 99.08% |
+| `010MB` | 12,709,008 B | 969 | 2,012 | 96.18% |
+| `100MB` | 102,679,666 B | 9,790 | 20,396 | 95.84% |
+| `300MB` | 302,689,973 B | 29,233 | 60,916 | 95.83% |
+| `500MB` | 502,678,782 B | 48,676 | 101,442 | 95.82% |
+| `600MB` | 602,666,385 B | 58,466 | 121,848 | 95.82% |
+| `001GB` | 1,002,677,454 B | 97,499 | 203,200 | 95.82% |
+| `total_4GB` | 4,002,669,404 B | 390,302 | 813,452 | 95.81% |
 
 The larger variants contain the content represented by the smaller variants, allowing different training scales without requiring manual concatenation.
 
 ---
 
-# Specialization
+# 🧹 Dataset Curation
 
-## Three.js
+Coder Max was built with a code-oriented preprocessing pipeline.
 
-Three.js is one of the primary specialization targets of OBSIDIAN.
+Important characteristics include:
 
-Training examples include patterns involving:
+### Code Density
 
-* scene creation;
-* perspective cameras;
-* lighting;
-* meshes;
-* materials;
-* geometry;
-* animation loops;
-* browser interaction;
-* keyboard input;
-* game mechanics;
-* 3D environments;
-* interactive simulations;
-* single-file applications.
+More than 95% of the larger corpus variants consist of code-oriented content.
 
-The goal is to teach the model to connect all required pieces of a Three.js application rather than merely output isolated API examples.
+### Python Syntax Validation
 
----
+Python blocks were structurally checked during preprocessing.
 
-## Frontend Generation
+Invalid or corrupted samples could therefore be removed before training.
 
-The model has strong exposure to complete frontend applications combining:
+### Complete Code Preservation
 
-```text
-HTML
-  │
-  ├── CSS
-  │
-  └── JavaScript
-        │
-        ├── DOM
-        ├── State
-        ├── Events
-        ├── Canvas
-        ├── Three.js
-        └── Animation
-```
+Long HTML, CSS and JavaScript applications are preserved rather than intentionally truncated.
 
-A typical training target may contain an entire application:
+This is especially important for teaching:
 
-```html
-<!DOCTYPE html>
-<html>
-<head>
-    <style>
-        /* Complete interface */
-    </style>
-</head>
+- closing tags;
+- application state;
+- complete functions;
+- event listeners;
+- rendering loops;
+- lifecycle logic.
 
-<body>
-    <main>
-        <!-- Complete application -->
-    </main>
+### Data Sanitization
 
-    <script>
-        // State
-        // Logic
-        // Rendering
-        // Interaction
-        // Animation loop
-    </script>
-</body>
-</html>
-```
+The preprocessing pipeline targets removal of artifacts such as:
 
----
-
-# Multilingual Programming
+- credentials;
+- API keys;
+- local IP addresses;
+- runtime artifacts.
 
-The training corpus contains programming instructions across 10 languages.
+### Provenance
 
-| Language  | Code |
-| --------- | ---- |
-| Português | `pt` |
-| English   | `en` |
-| Español   | `es` |
-| Français  | `fr` |
-| Deutsch   | `de` |
-| Italiano  | `it` |
-| 日本語       | `ja` |
-| 简体中文      | `zh` |
-| Русский   | `ru` |
-| Türkçe    | `tr` |
-
-The objective is to make programming capability less dependent on the language used in the instruction.
+Dataset records include SHA-256-based provenance metadata.
 
 ---
 
-# Fine-Tuning
+# 🧪 Fine-Tuning
 
 OBSIDIAN-9B-Coder was produced using supervised fine-tuning with **LoRA**.
 
-The training setup used for the model included:
+Training configuration:
 
 ```text
 Training method          LoRA
@@ -333,8 +373,6 @@ Context target           32,768
 Trainer                  Unsloth
 Optimizer                AdamW BNB 8-bit
 Scheduler                Cosine
-Batch size               1
-Gradient accumulation    1
 Response-only training   Enabled
 ```
 
@@ -352,34 +390,111 @@ down_proj
 
 ---
 
-# Training Strategy
+# 🧬 Training Strategy
 
-The model was trained with a code-heavy SFT corpus designed around long-form completions.
+The model was trained using a code-heavy SFT corpus designed around long-form completions.
 
 Important characteristics include:
 
-* long HTML responses;
-* complete application generation;
-* repeated high-value specialization examples;
-* multilingual prompt variants;
-* frontend-oriented training;
-* Three.js and Canvas exposure;
-* assistant-response-only loss.
+- 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.
 
-Intentional repetitions may exist in the source dataset as part of the specialization strategy.
+Some repetitions in the source dataset may be intentional.
 
-These repetitions are used to reinforce selected programming behaviors rather than representing accidental duplicate ingestion.
+Selected programming concepts and application patterns can be repeated to reinforce specific behaviors and specialization targets.
 
 ---
 
-# Example Prompts
+# 📦 GGUF
 
-## Three.js
+OBSIDIAN-9B-Coder is distributed in **GGUF** format for efficient local inference.
+
+Available quantizations include:
+
+| File | Quantization | Recommended Use |
+|---|---|---|
+| `Qwopus3.5-9B-Coder.Q8_0.gguf` | Q8_0 | Maximum practical GGUF fidelity |
+| `Qwopus3.5-9B-Coder.Q6_K.gguf` | Q6_K | High quality |
+| `Qwopus3.5-9B-Coder.Q5_K_M.gguf` | Q5_K_M | Quality / size balance |
+| `Qwopus3.5-9B-Coder.Q4_K_M.gguf` | Q4_K_M | Recommended general use |
+| `Qwopus3.5-9B-Coder.Q3_K_M.gguf` | Q3_K_M | Memory-constrained systems |
+| `Qwopus3.5-9B-Coder.BF16-mmproj.gguf` | BF16 mmproj | Multimodal projector |
+
+---
+
+# ⚖️ Quantization Guide
+
+```text
+              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.
+
+## Q5_K_M
+
+Strong compromise between model fidelity and memory requirements.
+
+## Q4_K_M
+
+Recommended starting point for most local deployments.
+
+## Q3_K_M
+
+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:
+
+```bash
+llama-cli -hf guell00/OBSIDIAN-9B-Coder --jinja
+```
+
+For compatible multimodal inference:
+
+```bash
+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
 
 ```text
 Create a complete Three.js game inside a single HTML file.
 
 Include:
+
 - responsive rendering;
 - perspective camera;
 - dynamic lighting;
@@ -392,6 +507,27 @@ Include:
 Return the complete HTML file.
 ```
 
+---
+
+## Frontend Application
+
+```text
+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
 
 ```text
@@ -403,6 +539,8 @@ estado interno e interação com o usuário.
 Retorne o arquivo HTML completo.
 ```
 
+---
+
 ## Canvas
 
 ```text
@@ -413,6 +551,8 @@ Include mouse interaction, animation, responsive resizing
 and performance-conscious rendering.
 ```
 
+---
+
 ## Python
 
 ```text
@@ -423,171 +563,265 @@ Explain the algorithm briefly and return working code.
 
 ---
 
-# Recommended Generation
+# 🎛️ Generation Settings
 
 Coding tasks generally benefit from conservative sampling.
 
-A reasonable starting point is:
+A reasonable starting point:
 
 ```text
 temperature: 0.2
 top_p: 0.9
 ```
 
-For creative frontend generation:
+For more creative frontend generation:
 
 ```text
 temperature: 0.5 - 0.7
 top_p: 0.9 - 0.95
 ```
 
-These values are starting points rather than guarantees.
+These values are starting points rather than guaranteed optimal settings.
 
-Generation settings should be benchmarked for the target workload.
+Generation parameters should be benchmarked for the target workload.
 
 ---
 
-# Intended Use
+# 🎯 Intended Use
 
 OBSIDIAN-9B-Coder is intended for:
 
-* coding assistants;
-* frontend code generation;
-* HTML/CSS/JavaScript generation;
-* Three.js generation;
-* Canvas applications;
-* Python programming;
-* programming experiments;
-* multilingual coding assistants;
-* local coding models;
-* research into code-specialized fine-tuning.
+- 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 Recommendations
-
-For coding models such as OBSIDIAN, executable evaluation is strongly recommended.
-
-Useful evaluation categories include:
+# 📏 Evaluation
 
-* HTML completeness;
-* CSS validity;
-* JavaScript syntax;
-* Three.js initialization;
-* rendering-loop correctness;
-* DOM interaction;
-* Canvas rendering;
-* Python syntax;
-* algorithmic correctness;
-* long-response completion;
-* multilingual instruction following.
+Executable evaluation is strongly recommended for coding models.
 
 A useful evaluation pipeline is:
 
 ```text
+PROMPT
+  │
+  ▼
 GENERATE
-   ↓
+  │
+  ▼
 PARSE
-   ↓
+  │
+  ▼
 EXECUTE
-   ↓
+  │
+  ▼
 INSPECT
-   ↓
+  │
+  ▼
 TEST
 ```
 
-Execution matters more than text similarity when evaluating generated software.
+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
+# ⚠️ 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.
+- 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.
 
-The model's context capacity also does not guarantee perfect reasoning or perfect retention across every token in a long context.
+Long context capacity also does not guarantee perfect reasoning or perfect retention across every token of a long prompt.
 
 ---
 
-# Dataset Integrity
+# 🧬 Model Lineage
+
+OBSIDIAN-9B-Coder was **not trained from scratch**.
 
-Coder Max includes metadata intended to support corpus integrity and provenance tracking.
+Its lineage is:
 
-Dataset preparation includes:
+```text
+Qwen3.5 family
+       │
+       ▼
+Jackrong/Qwopus3.5-9B-Coder
+       │
+       ▼
+Coder Max Multilingual
+       │
+       ▼
+LoRA Supervised Fine-Tuning
+       │
+       ▼
+OBSIDIAN-9B-Coder
+       │
+       ▼
+GGUF Quantizations
+```
 
-* syntax-oriented filtering;
-* preservation of complete code;
-* credential and runtime artifact sanitization;
-* SHA-256 provenance metadata;
-* multilingual prompt labeling;
-* frontend classification metadata.
+OBSIDIAN therefore inherits substantial pretrained and coding capabilities from its base model while adding specialization through Coder Max.
 
 ---
 
-# Base Model
+# 📚 Training Sources
+
+## Base Model
 
-OBSIDIAN-9B-Coder is a **fine-tuned derivative model**.
+OBSIDIAN-9B-Coder was fine-tuned from:
 
-The underlying pretrained capabilities and architecture originate from the declared base model.
+**Jackrong/Qwopus3.5-9B-Coder**
 
-OBSIDIAN should therefore not be interpreted as a foundation model trained from scratch.
+Hugging Face:
 
-Users redistributing or deploying the model should review the licensing and usage requirements of the underlying model and training data.
+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.
 
 ---
 
-# Model Identity
+## Fine-Tuning Dataset
 
-**Model:** OBSIDIAN-9B-Coder
+The dataset used for the OBSIDIAN fine-tuning stage was:
 
-**Dataset:** Coder Max Multilingual
+**Coder Max Multilingual**
 
 **Author:** guell00
 
-**Training framework:** Unsloth
+Hugging Face:
 
-**Format:** GGUF
+https://huggingface.co/datasets/guell00/Coder-max
 
-**Specialization:**
+Coder Max provides the additional specialization toward:
 
-`Three.js` • `JavaScript` • `HTML` • `CSS` • `Canvas` • `Python` • `Multilingual`
+- complete code generation;
+- HTML/CSS/JavaScript;
+- Three.js;
+- Canvas;
+- Python;
+- interactive applications;
+- long-form implementations;
+- multilingual programming instructions.
 
 ---
 
-# Summary
+# 🏗️ Training Stack
 
-OBSIDIAN-9B-Coder is a 9B coding model specialized through supervised fine-tuning on a highly code-dense multilingual dataset.
+```text
+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
 
-Its main focus is:
+For **Qwopus3.5-9B-Coder**, used as the direct base model for this fine-tuning.
 
-> **Generating complete software instead of fragmented examples.**
+### Unsloth
 
-Primary strengths include:
+For the efficient fine-tuning and model conversion tooling used during training.
 
-* frontend code generation;
-* Three.js;
-* JavaScript;
-* complete HTML applications;
-* Canvas;
-* Python;
-* multilingual programming instructions;
-* long code outputs.
+### guell00
+
+For:
+
+- **Coder Max Multilingual**
+- OBSIDIAN fine-tuning
+- dataset preparation
+- model specialization
+- GGUF release
 
 ---
 
-## OBSIDIAN-9B-Coder
+# 💎 OBSIDIAN-9B-Coder
+
+```text
+Base
+  Jackrong/Qwopus3.5-9B-Coder
+
+        +
+
+Dataset
+  guell00/Coder-max
+
+        +
+
+Fine-Tuning
+  LoRA SFT / Unsloth
+
+        =
+
+  OBSIDIAN-9B-Coder
+```
 
-**Complete Code • Long Context • Interactive Software**
+**9B · 32K Training Context · Three.js · JavaScript · HTML · CSS · Canvas · Python · Multilingual**
 
-`Three.js` • `JavaScript` • `HTML` • `CSS` • `Canvas` • `Python` • `Multilingual`
+> **OBSIDIAN-9B-Coder — specialized for complete code generation.**