license: mit
language:
- pt
- en
- es
- fr
base_model:
- ornith-ai/Ornith-1.5-9B
tags:
- coder
- code
- programmer
- edge
- fast
- smart
LEVUM
👉 Visit the Velum AI Landing Page
Local · Code · Software
A local model based on Qwen 3.5 9B, focused on software development.
Write. Understand. Fix. Refactor. Build.
Less ceremony. More working code.
About
LEVUM is a 9-billion-parameter model, based on Qwen 3.5 9B and focused on software development tasks.
The goal is simple: work close to the project and turn instructions into useful code.
The model was designed for tasks such as:
- code generation;
- feature implementation;
- debugging;
- refactoring;
- code explanation and understanding;
- prototype creation;
- project structuring;
- complete application generation;
- assistance during local development.
LEVUM follows a local-first philosophy: the model can run close to the IDE, files, and the actual project context, depending on the chosen runtime and quantization.
Software first. Local by default.
Specifications
| Model | LEVUM |
| Base | Qwen 3.5 9B |
| Parameters | 9B |
| Focus | Code / Software |
| Primary use | Software development |
| Execution | Local |
| Language | English + multilingual capabilities of the base model |
| Origin | 🇧🇷 Brazil |
Quantizations
LEVUM is available in different quantization levels to support a wider range of hardware.
The ideal choice mainly depends on:
RAM / VRAM → speed → fidelity
Comparison of the model's relative quality after different quantization levels:
Defined values: Q8 = 99%, Q4 = 50%, Q3 = 30%, Q2 = 25%, and Q1 = 10%.
Q8 — Fidelity
For machines with enough memory and users who want to preserve as much of the model's quality as possible.
Q8_0
Q4 / IQ4 — Balanced
The recommended sweet spot for many local systems.
A good balance between size, memory usage, and quality.
Q4_K_M · Q4_K_S · IQ4_XS · IQ4_NL · Q4_1 · Q4_0
Q3 / IQ3 — Compact
For more limited hardware or situations where reducing RAM/VRAM usage is a priority.
Q3_K_L · Q3_K_M · Q3_K_S · IQ3_M · IQ3_S · IQ3_XS · IQ3_XXS
Q2 / IQ2 — Ultra-Compact
Aggressive compression for environments where larger versions simply do not fit.
Q2_K · Q2_K_S · IQ2_M · IQ2_S · IQ2_XS · IQ2_XXS · Q2_0 · TQ2_0
IQ1 — Minimum
The extreme option.
IQ1_M
Recommended only when saving memory is more important than preserving maximum model fidelity.
Rule of thumb: start with
Q4_K_M. If you have memory to spare, tryQ8_0. If memory is limited, move down to Q3, Q2, or IQ1.
Running Locally
llama.cpp
Download one of the GGUF versions of LEVUM and run it with a GGUF-compatible runtime.
llama-cli \
-m ./LEVUM-Q4_K_M.gguf \
-p "Create a REST API in Python using FastAPI."
To start a local server:
llama-server \
-m ./LEVUM-Q4_K_M.gguf \
-c 8192
After that, the model can be integrated with local tools that support compatible endpoints.
Ollama
Create a Modelfile pointing to the GGUF:
FROM ./LEVUM-Q4_K_M.gguf
PARAMETER temperature 0.6
PARAMETER top_p 0.9
Then:
ollama create levum -f Modelfile
ollama run levum
Example:
>>> Create a FastAPI API for managing projects and tasks.
LM Studio
- Download a GGUF quantization of LEVUM.
- Import the file into LM Studio.
- Load the model.
- Adjust the context size according to the available memory.
- Start a conversation or the local server.
No remote infrastructure is required for inference when the model is running locally.
Prompts
LEVUM works best when the task, context, and expected output format are explicit.
Generate a Project
Create an interactive financial dashboard in a single HTML file.
Requirements:
- HTML, CSS, and JavaScript in the same file
- interactive charts
- responsive
- sample data
- no mandatory external dependencies
Return only the complete HTML.
Implement a Feature
Analyze the code below and implement JWT authentication.
Requirements:
- preserve the current architecture
- validate expired tokens
- add authentication middleware
- do not modify public endpoints
- explain only important decisions
Code:
[paste the code here]
Debug
Find the cause of the bug in the code below.
Expected behavior:
[describe]
Current behavior:
[describe]
Error:
[paste the error]
Code:
[paste the code]
Identify the cause and return the complete fix.
Refactoring
Refactor this code.
Goals:
- reduce duplication
- improve readability
- preserve current behavior
- preserve the public API
- avoid unnecessary abstractions
Return the refactored code first, followed by a short summary of the changes.
Prompt Format
For larger tasks, a simple structure usually produces more predictable results:
OBJECTIVE
What needs to be built.
CONTEXT
Stack, existing files, and architecture.
REQUIREMENTS
Mandatory behaviors.
CONSTRAINTS
What must not be changed.
OUTPUT
Exact expected format.
For example:
OBJECTIVE
Create an analytics page.
CONTEXT
React + TypeScript + Tailwind project.
REQUIREMENTS
- revenue chart
- period filters
- metric cards
- transactions table
CONSTRAINTS
- do not add new dependencies
- reuse existing components
OUTPUT
Return the complete files that need to be created or modified.
Code-first
LEVUM was designed to work within the normal development cycle:
PROMPT / CODE
↓
LEVUM
↓
UNDERSTAND
↓
GENERATE
↓
DEBUG
↓
REFACTOR
↓
RUNNING SOFTWARE
Generation
Projects, components, APIs, scripts, and features.
Debug
Analysis of errors, unexpected behavior, and fixes.
Refactoring
Structure, readability, and maintenance of existing code.
Prototyping
Turn an idea into something executable quickly.
Example
Prompt
Create a Flappy Bird-style game in a single HTML file.
Use only HTML, CSS, and JavaScript.
Include:
- physics
- obstacles
- collision detection
- scoring
- restart
- keyboard and click controls
Return only the complete HTML.
Expected result
prompt
↓
LEVUM
↓
HTML + CSS + JavaScript
↓
browser
↓
running software
Hardware
Actual resource usage depends on several factors, including:
- quantization;
- context size;
- runtime;
- KV cache;
- CPU;
- GPU;
- number of layers offloaded to the GPU;
- inference configuration.
Because of this, memory requirements can vary significantly between systems.
As a general rule:
more bits
↑
more fidelity
↑
more memory
fewer bits
↓
less memory
↓
more compression
Choose the quantization based on the available hardware and the quality required for the task.
Limitations
LEVUM is still a language model.
This means it may:
- generate incorrect code;
- hallucinate APIs or libraries;
- produce insecure solutions;
- misinterpret requirements;
- introduce regressions;
- suggest nonexistent dependencies;
- generate code that looks correct without actually working.
For important software, review, test, and validate the code before putting it into production.
AI-generated code does not gain magical powers just because it compiled once.
Responsible Use
Before running code generated by the model:
- review the changes;
- verify dependencies;
- run tests;
- validate external inputs;
- review filesystem, network, and database operations;
- do not expose secrets or credentials unnecessarily;
- use isolated environments when testing unknown code.
For critical applications, the model should serve as an assistance tool, not as the only layer of review.
Base Model
LEVUM is based on:
Qwen 3.5 9B
The base model provides the general capabilities upon which LEVUM is built.
Also review the base model's model card and license before distributing or using derivatives.
License
Use of LEVUM is subject to the license published in this repository and, where applicable, the terms and conditions associated with the base model.
Review the LICENSE file before commercial use, redistribution, or creating derivatives.