Update README.md

README.md

@@ -3,8 +3,10 @@ license: mit
 language:
 - pt
 - en
+- es
+- fr
 base_model:
-- AtomicChat/Ornith-1.5-9B-GGUF
+- ornith-ai/Ornith-1.5-9B
 tags:
 - coder
 - code
@@ -13,146 +15,144 @@ tags:
 - fast
 - smart
 ---
-
 <div align="center">
 
-
 ![image](https://cdn-uploads.huggingface.co/production/uploads/644afe169279988e0cbcd2d9/jCFCVTpFLOvaCUOF90b9o.png)
 
 <br>
 
 # LEVUM
 
-[👉 Acesse a Landing Page do Velum AI](https://guell11.github.io/velum-ai/)
+[👉 Visit the Velum AI Landing Page](https://guell11.github.io/velum-ai/)
 
-### Local · Código · Software
+### Local · Code · Software
 
-**Um modelo local baseado em Qwen 3.5 9B, direcionado para desenvolvimento de software.**
+**A local model based on Qwen 3.5 9B, focused on software development.**
 
-Escrever. Entender. Corrigir. Refatorar. Construir.
+Write. Understand. Fix. Refactor. Build.
 
-**Menos cerimônia. Mais código rodando.**
+**Less ceremony. More working code.**
 
 </div>
 
 ---
 
-## Sobre
+## About
 
-**LEVUM** é um modelo de **9 bilhões de parâmetros**, baseado em **Qwen 3.5 9B** e direcionado para tarefas de desenvolvimento de software.
+**LEVUM** is a **9-billion-parameter model**, based on **Qwen 3.5 9B** and focused on software development tasks.
 
-O objetivo é simples: trabalhar perto do projeto e transformar instruções em código útil.
+The goal is simple: work close to the project and turn instructions into useful code.
 
-O modelo foi pensado para tarefas como:
+The model was designed for tasks such as:
 
-* geração de código;
-* implementação de features;
+* code generation;
+* feature implementation;
 * debugging;
-* refatoração;
-* explicação e leitura de código;
-* criação de protótipos;
-* estruturação de projetos;
-* geração de aplicações completas;
-* assistência durante desenvolvimento local.
+* refactoring;
+* code explanation and understanding;
+* prototype creation;
+* project structuring;
+* complete application generation;
+* assistance during local development.
 
-LEVUM segue uma filosofia **local-first**: o modelo pode rodar próximo da IDE, dos arquivos e do contexto real do projeto, dependendo do runtime e da quantização escolhidos.
+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 primeiro. Local por padrão.**
+> **Software first. Local by default.**
 
 ---
 
-## Especificações
+## Specifications
 
-|                   |                                              |
-| ----------------- | -------------------------------------------- |
-| **Modelo**        | LEVUM                                        |
-| **Base**          | Qwen 3.5 9B                                  |
-| **Parâmetros**    | 9B                                           |
-| **Foco**          | Código / Software                            |
-| **Uso principal** | Desenvolvimento de software                  |
-| **Execução**      | Local                                        |
-| **Idioma**        | Português + capacidades multilíngues da base |
-| **Origem**        | 🇧🇷 Brasil                                  |
+|                 |                                                       |
+| --------------- | ----------------------------------------------------- |
+| **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                                           |
 
 ---
 
-# Quantizações
+# Quantizations
 
-LEVUM é disponibilizado em diferentes níveis de quantização para permitir execução em uma variedade maior de hardware.
+LEVUM is available in different quantization levels to support a wider range of hardware.
 
-A escolha ideal depende principalmente de:
+The ideal choice mainly depends on:
 
-**RAM / VRAM → velocidade → fidelidade**
+**RAM / VRAM → speed → fidelity**
 
-Comparação da qualidade relativa do modelo após diferentes níveis de quantização:
+Comparison of the model's relative quality after different quantization levels:
 
 ![image](https://cdn-uploads.huggingface.co/production/uploads/644afe169279988e0cbcd2d9/Kqx6ACbFDrb_UG0Zmah4z.png)
 
-Valores definidos: Q8 = 99%, Q4 = 50%, Q3 = 30%, Q2 = 25% e Q1 = 10%.
+Defined values: Q8 = 99%, Q4 = 50%, Q3 = 30%, Q2 = 25%, and Q1 = 10%.
 
-### Q8 — Fidelidade
+### Q8 — Fidelity
 
-Para máquinas com memória suficiente e usuários que querem preservar o máximo possível da qualidade do modelo.
+For machines with enough memory and users who want to preserve as much of the model's quality as possible.
 
 `Q8_0`
 
 ---
 
-### Q4 / IQ4 — Equilíbrio
+### Q4 / IQ4 — Balanced
 
-O ponto recomendado para muitos sistemas locais.
+The recommended sweet spot for many local systems.
 
-Boa relação entre tamanho, consumo de memória e qualidade.
+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 — Compacto
+### Q3 / IQ3 — Compact
 
-Para hardware mais limitado ou situações onde reduzir RAM/VRAM é prioridade.
+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 — Ultracompacto
+### Q2 / IQ2 — Ultra-Compact
 
-Compressão agressiva para ambientes onde versões maiores simplesmente não cabem.
+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 — Mínimo
+### IQ1 — Minimum
 
-A opção extrema.
+The extreme option.
 
 `IQ1_M`
 
-Indicada apenas quando economia de memória é mais importante do que preservar a fidelidade máxima do modelo.
+Recommended only when saving memory is more important than preserving maximum model fidelity.
 
 ---
 
-> **Regra prática:** comece com `Q4_K_M`.
-> Se houver memória sobrando, experimente `Q8_0`.
-> Se faltar memória, desça para Q3, Q2 ou IQ1.
+> **Rule of thumb:** start with `Q4_K_M`.
+> If you have memory to spare, try `Q8_0`.
+> If memory is limited, move down to Q3, Q2, or IQ1.
 
 ---
 
-# Executando localmente
+# Running Locally
 
 ## llama.cpp
 
-Baixe uma das versões GGUF do LEVUM e execute com um runtime compatível com GGUF.
+Download one of the GGUF versions of LEVUM and run it with a GGUF-compatible runtime.
 
 ```bash
 llama-cli \
   -m ./LEVUM-Q4_K_M.gguf \
-  -p "Crie uma API REST em Python usando FastAPI."
+  -p "Create a REST API in Python using FastAPI."
 ```
 
-Para iniciar um servidor local:
+To start a local server:
 
 ```bash
 llama-server \
@@ -160,13 +160,13 @@ llama-server \
   -c 8192
 ```
 
-Depois disso, o modelo pode ser integrado a ferramentas locais que suportem endpoints compatíveis.
+After that, the model can be integrated with local tools that support compatible endpoints.
 
 ---
 
 ## Ollama
 
-Crie um `Modelfile` apontando para o GGUF:
+Create a `Modelfile` pointing to the GGUF:
 
 ```dockerfile
 FROM ./LEVUM-Q4_K_M.gguf
@@ -175,68 +175,68 @@ PARAMETER temperature 0.6
 PARAMETER top_p 0.9
 ```
 
-Depois:
+Then:
 
 ```bash
 ollama create levum -f Modelfile
 ollama run levum
 ```
 
-Exemplo:
+Example:
 
 ```text
->>> Crie uma API em FastAPI para gerenciar projetos e tarefas.
+>>> Create a FastAPI API for managing projects and tasks.
 ```
 
 ---
 
 ## LM Studio
 
-1. Baixe uma quantização GGUF do LEVUM.
-2. Importe o arquivo no LM Studio.
-3. Carregue o modelo.
-4. Ajuste o contexto de acordo com a memória disponível.
-5. Inicie uma conversa ou o servidor local.
+1. Download a GGUF quantization of LEVUM.
+2. Import the file into LM Studio.
+3. Load the model.
+4. Adjust the context size according to the available memory.
+5. Start a conversation or the local server.
 
-Nenhuma infraestrutura remota é necessária para a inferência quando o modelo está sendo executado localmente.
+No remote infrastructure is required for inference when the model is running locally.
 
 ---
 
 # Prompts
 
-LEVUM funciona melhor quando a tarefa, o contexto e o formato esperado são explícitos.
+LEVUM works best when the task, context, and expected output format are explicit.
 
-## Gerar um projeto
+## Generate a Project
 
 ```text
-Crie um dashboard financeiro interativo em um único arquivo HTML.
+Create an interactive financial dashboard in a single HTML file.
 
-Requisitos:
-- HTML, CSS e JavaScript no mesmo arquivo
-- gráficos interativos
-- responsivo
-- dados de exemplo
-- sem dependências externas obrigatórias
+Requirements:
+- HTML, CSS, and JavaScript in the same file
+- interactive charts
+- responsive
+- sample data
+- no mandatory external dependencies
 
-Retorne somente o HTML completo.
+Return only the complete HTML.
 ```
 
 ---
 
-## Implementar uma feature
+## Implement a Feature
 
 ```text
-Analise o código abaixo e implemente autenticação JWT.
+Analyze the code below and implement JWT authentication.
 
-Requisitos:
-- preserve a arquitetura atual
-- valide tokens expirados
-- adicione middleware de autenticação
-- não altere endpoints públicos
-- explique apenas decisões importantes
+Requirements:
+- preserve the current architecture
+- validate expired tokens
+- add authentication middleware
+- do not modify public endpoints
+- explain only important decisions
 
-Código:
-[cole o código aqui]
+Code:
+[paste the code here]
 ```
 
 ---
@@ -244,147 +244,147 @@ Código:
 ## Debug
 
 ```text
-Encontre a causa do bug no código abaixo.
+Find the cause of the bug in the code below.
 
-Comportamento esperado:
-[descreva]
+Expected behavior:
+[describe]
 
-Comportamento atual:
-[descreva]
+Current behavior:
+[describe]
 
-Erro:
-[cole o erro]
+Error:
+[paste the error]
 
-Código:
-[cole o código]
+Code:
+[paste the code]
 
-Identifique a causa e retorne a correção completa.
+Identify the cause and return the complete fix.
 ```
 
 ---
 
-## Refatoração
+## Refactoring
 
 ```text
-Refatore este código.
+Refactor this code.
 
-Objetivos:
-- reduzir duplicação
-- melhorar legibilidade
-- manter comportamento atual
-- preservar a API pública
-- evitar abstrações desnecessárias
+Goals:
+- reduce duplication
+- improve readability
+- preserve current behavior
+- preserve the public API
+- avoid unnecessary abstractions
 
-Retorne primeiro o código refatorado e depois um resumo curto das mudanças.
+Return the refactored code first, followed by a short summary of the changes.
 ```
 
 ---
 
-# Formato de prompt
+# Prompt Format
 
-Para tarefas maiores, uma estrutura simples costuma produzir resultados mais previsíveis:
+For larger tasks, a simple structure usually produces more predictable results:
 
 ```text
-OBJETIVO
-O que precisa ser construído.
+OBJECTIVE
+What needs to be built.
 
-CONTEXTO
-Stack, arquivos existentes e arquitetura.
+CONTEXT
+Stack, existing files, and architecture.
 
-REQUISITOS
-Comportamentos obrigatórios.
+REQUIREMENTS
+Mandatory behaviors.
 
-RESTRIÇÕES
-O que não deve ser alterado.
+CONSTRAINTS
+What must not be changed.
 
-SAÍDA
-Formato exato esperado.
+OUTPUT
+Exact expected format.
 ```
 
-Por exemplo:
+For example:
 
 ```text
-OBJETIVO
-Criar uma página de analytics.
+OBJECTIVE
+Create an analytics page.
 
-CONTEXTO
-Projeto React + TypeScript + Tailwind.
+CONTEXT
+React + TypeScript + Tailwind project.
 
-REQUISITOS
-- gráfico de receita
-- filtros por período
-- cards de métricas
-- tabela de transações
+REQUIREMENTS
+- revenue chart
+- period filters
+- metric cards
+- transactions table
 
-RESTRIÇÕES
-- não adicionar novas dependências
-- reutilizar componentes existentes
+CONSTRAINTS
+- do not add new dependencies
+- reuse existing components
 
-SAÍDA
-Retorne os arquivos completos que precisam ser criados ou alterados.
+OUTPUT
+Return the complete files that need to be created or modified.
 ```
 
 ---
 
 # Code-first
 
-LEVUM foi pensado para trabalhar dentro do ciclo normal de desenvolvimento:
+LEVUM was designed to work within the normal development cycle:
 
 ```text
-PROMPT / CÓDIGO
+PROMPT / CODE
       ↓
     LEVUM
       ↓
-   ENTENDER
+  UNDERSTAND
       ↓
-    GERAR
+   GENERATE
       ↓
     DEBUG
       ↓
-  REFATORAR
+  REFACTOR
       ↓
-SOFTWARE RODANDO
+RUNNING SOFTWARE
 ```
 
-### Geração
+### Generation
 
-Projetos, componentes, APIs, scripts e features.
+Projects, components, APIs, scripts, and features.
 
 ### Debug
 
-Análise de erros, comportamento inesperado e correções.
+Analysis of errors, unexpected behavior, and fixes.
 
-### Refatoração
+### Refactoring
 
-Estrutura, legibilidade e manutenção de código existente.
+Structure, readability, and maintenance of existing code.
 
-### Prototipagem
+### Prototyping
 
-Transformar uma ideia em algo executável rapidamente.
+Turn an idea into something executable quickly.
 
 ---
 
-# Exemplo
+# Example
 
 **Prompt**
 
 ```text
-Crie um jogo estilo Flappy Bird em um único HTML.
+Create a Flappy Bird-style game in a single HTML file.
 
-Use apenas HTML, CSS e JavaScript.
+Use only HTML, CSS, and JavaScript.
 
-Inclua:
-- física
-- obstáculos
-- colisão
-- pontuação
-- reinício
-- controles por teclado e clique
+Include:
+- physics
+- obstacles
+- collision detection
+- scoring
+- restart
+- keyboard and click controls
 
-Retorne somente o HTML completo.
+Return only the complete HTML.
 ```
 
-**Resultado esperado**
+**Expected result**
 
 ```text
 prompt
@@ -395,109 +395,109 @@ HTML + CSS + JavaScript
   ↓
 browser
   ↓
-software rodando
+running software
 ```
 
 ---
 
 # Hardware
 
-O consumo real depende de vários fatores, incluindo:
+Actual resource usage depends on several factors, including:
 
-* quantização;
-* tamanho do contexto;
+* quantization;
+* context size;
 * runtime;
 * KV cache;
 * CPU;
 * GPU;
-* quantidade de camadas descarregadas para GPU;
-* configuração de inferência.
+* number of layers offloaded to the GPU;
+* inference configuration.
 
-Por isso, os números de memória podem variar significativamente entre sistemas.
+Because of this, memory requirements can vary significantly between systems.
 
-Como regra geral:
+As a general rule:
 
 ```text
-mais bits
+more bits
    ↑
-mais fidelidade
+more fidelity
    ↑
-mais memória
+more memory
 
-menos bits
+fewer bits
    ↓
-menos memória
+less memory
    ↓
-maior compressão
+more compression
 ```
 
-Escolha a quantização com base no hardware disponível e na qualidade necessária para a tarefa.
+Choose the quantization based on the available hardware and the quality required for the task.
 
 ---
 
-# Limitações
+# Limitations
 
-LEVUM continua sendo um modelo de linguagem.
+LEVUM is still a language model.
 
-Isso significa que ele pode:
+This means it may:
 
-* gerar código incorreto;
-* inventar APIs ou bibliotecas;
-* produzir soluções inseguras;
-* interpretar requisitos de forma errada;
-* introduzir regressões;
-* sugerir dependências inexistentes;
-* gerar código que parece correto sem realmente funcionar.
+* 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.
 
-Para software importante, revise, teste e valide o código antes de colocá-lo em produção.
+For important software, review, test, and validate the code before putting it into production.
 
-Código gerado por IA não ganha poderes mágicos só porque compilou uma vez.
+AI-generated code does not gain magical powers just because it compiled once.
 
 ---
 
-# Uso responsável
+# Responsible Use
 
-Antes de executar código gerado pelo modelo:
+Before running code generated by the model:
 
-1. revise as alterações;
-2. verifique dependências;
-3. execute testes;
-4. valide entradas externas;
-5. revise operações de filesystem, rede e banco de dados;
-6. não exponha segredos ou credenciais desnecessariamente;
-7. use ambientes isolados quando estiver testando código desconhecido.
+1. review the changes;
+2. verify dependencies;
+3. run tests;
+4. validate external inputs;
+5. review filesystem, network, and database operations;
+6. do not expose secrets or credentials unnecessarily;
+7. use isolated environments when testing unknown code.
 
-Para aplicações críticas, o modelo deve funcionar como ferramenta de assistência, não como única camada de revisão.
+For critical applications, the model should serve as an assistance tool, not as the only layer of review.
 
 ---
 
-# Modelo base
+# Base Model
 
-LEVUM é baseado em:
+LEVUM is based on:
 
 **Qwen 3.5 9B**
 
-O modelo base fornece a capacidade geral sobre a qual o LEVUM é construído.
+The base model provides the general capabilities upon which LEVUM is built.
 
-Consulte também o model card e a licença do modelo base antes de distribuir ou utilizar derivados.
+Also review the base model's model card and license before distributing or using derivatives.
 
 ---
 
-# Licença
+# License
 
-O uso do LEVUM está sujeito à licença publicada neste repositório e, quando aplicável, aos termos e condições associados ao modelo base.
+Use of LEVUM is subject to the license published in this repository and, where applicable, the terms and conditions associated with the base model.
 
-Consulte o arquivo `LICENSE` antes de uso comercial, redistribuição ou criação de derivados.
+Review the `LICENSE` file before commercial use, redistribution, or creating derivatives.
 
 ---
 
-# Brasil
+# Brazil
 
 <div align="center">
 
-### 🇧🇷 FEITO NO BRASIL
+### 🇧🇷 MADE IN BRAZIL
 
-**Inteligência que fica por perto.**
+**Intelligence that stays close.**
 
 Local-first · Code-first · Software-first
 
@@ -509,4 +509,4 @@ Local-first · Code-first · Software-first
 
 **LEVUM © 2026**
 
-</div>
+</div>