chore: rename FALCON → RAVEN across docs and website

Docs:
- Remove logo image from README.md and README.pt-BR.md
- Replace all FALCON references with RAVEN in syscalls.md/.pt-BR.md
- Fix outdated "floating-point not yet implemented" in format.md/.pt-BR.md
  (RV32F is fully supported since v1.16)
- Fix GitHub URLs to Gaok1/Raven (correct casing)

Website:
- Apply RAVEN app color palette (neutral dark + violet) — mirrors theme.rs
- Replace red/orange theme with neutral grays and electric violet accent
- Replace raven logo with interactive TUI preview (Editor/Run/Cache/Docs tabs)
- Remove all FALCON-ASM references from HTML, CSS, JS comments
- Add RV32F category to ISA grid
- Remove emoji icons from feature/audience lists
- Fix all footer hrefs to absolute GitHub URLs
- Improve Run tab preview: instruction decoder panel instead of register list
- Add Write → Run → Understand workflow section (3 steps)
- Add palette.css: canonical color reference mirroring src/ui/theme.rs

Author: Gaok1

docs/README.pt-BR.md

@@ -1,8 +1,6 @@
-# FALCON ASM — Emulador e IDE RISC-V
+# RAVEN — Emulador e IDE RISC-V
 
-<img src="https://github.com/user-attachments/assets/b0a9c716-3750-4aba-85f0-6957d2b510fc" height="400"/>
-
-**FALCON ASM** é um emulador, montador e IDE RISC-V rodando no terminal, escrito em Rust. Cobre **RV32I + M + F** e foi pensado para tornar cada etapa do ciclo buscar → decodificar → executar visível e interativa — ideal para estudantes, professores e qualquer um aprendendo assembly.
+**RAVEN** é um emulador, montador e IDE RISC-V rodando no terminal, escrito em Rust. Cobre **RV32I + M + F** e foi pensado para tornar cada etapa do ciclo buscar → decodificar → executar visível e interativa — ideal para estudantes, professores e qualquer um aprendendo assembly.
 
 Tudo vive em uma única TUI: escreva código, monte, execute passo a passo, inspecione registradores e memória, perfile sua hierarquia de cache e leia a documentação — sem sair do terminal.
 
@@ -69,11 +67,11 @@ Tudo vive em uma única TUI: escreva código, monte, execute passo a passo, insp
 
 ## Início Rápido
 
-Baixe o binário mais recente em [Releases](https://github.com/Gaok1/FALCON-ASM/releases), ou compile da fonte:
+Baixe o binário mais recente em [Releases](https://github.com/Gaok1/Raven/releases), ou compile da fonte:
 
 ```bash
-git clone https://github.com/Gaok1/FALCON-ASM.git
-cd FALCON-ASM
+git clone https://github.com/Gaok1/Raven.git
+cd RAVEN
 cargo run
 ```
 

docs/format.md

@@ -1,6 +1,6 @@
-# Falcon ASM format guide — RV32I in plain language
+# RAVEN format guide — RV32I in plain language
 
-This is the companion reference for Falcon ASM, our teaching-friendly RISC-V emulator. Use it as a cheat sheet.
+This is the companion reference for RAVEN, our teaching-friendly RISC-V emulator. Use it as a cheat sheet.
 
 ## How to read this document
 
@@ -11,18 +11,17 @@ This is the companion reference for Falcon ASM, our teaching-friendly RISC-V emu
 
 ## Architecture snapshot
 
-Falcon focuses on a approachable RV32I+M subset so you can reason about each pipeline stage without being buried in extras.
+RAVEN focuses on a approachable RV32I+M subset so you can reason about each pipeline stage without being buried in extras.
 
 - **Word size:** 32 bits.
 - **Endianness:** little-endian throughout (`{to,from}_le_bytes`).
 - **Program counter:** advances by 4 each instruction; branches and jumps are PC-relative.
 - **Registers:** hardware names `x0…x31` with the usual aliases `zero`, `ra`, `sp`, `gp`, `tp`, `t0…t6`, `s0/fp`, `s1`, `a0…a7`,
   `s2…s11`. Writes to `x0/zero` are ignored.
 
-Not yet implemented: CSR/FENCE instructions and any floating-point extension. Keeping the surface area small makes Falcon easier to
-use in class or during workshops.
+Not yet implemented: CSR/FENCE instructions. RAVEN covers RV32IMF — base integer, multiply/divide, and single-precision float.
 
-## Instruction set inside Falcon
+## Instruction set inside RAVEN
 
 | Category | Instructions |
 | --- | --- |
@@ -39,7 +38,7 @@ of following the architected “divide-by-zero” results. The interruption make
 
 ## Encoding cheat sheets
 
-The tables below show all 32-bit layouts Falcon uses. When an instruction name appears in bold, read the note beneath the table for
+The tables below show all 32-bit layouts RAVEN uses. When an instruction name appears in bold, read the note beneath the table for
 a reminder about immediate ranges or special cases.
 
 ### R-type (arithmetic, logic, multiply/divide)
@@ -162,20 +161,20 @@ a reminder about immediate ranges or special cases.
 
 **`JALR` (`0x67`):** uses `funct3 = 0x0`.
 
-**System (`0x73`):** Falcon implements two encodings: `ECALL` (`0x00000073`) and `EBREAK` (`0x00100073`). The assembler accepts
+**System (`0x73`):** RAVEN implements two encodings: `ECALL` (`0x00000073`) and `EBREAK` (`0x00100073`). The assembler accepts
 `halt` as an alias for `ebreak`.
 
 ## Assembler behaviour and pseudo-instructions
 
-Falcon’s assembler is intentionally lightweight so you can follow every step:
+RAVEN’s assembler is intentionally lightweight so you can follow every step:
 
 - Comments begin with `;` or `#`.
 - Operands are comma-separated (`mnemonic op1, op2, ...`).
 - Supported sections/directives include `.text`, `.data`, `.bss`, `.section`, `.word`, `.byte`, `.half`, `.ascii`, `.asciz`/`.asciiz`, `.space`, and `.align`.
 
 ### Pseudo-instructions reference
 
-The table below documents the pseudo forms implemented by Falcon and the exact expansion shape used by the assembler.
+The table below documents the pseudo forms implemented by RAVEN and the exact expansion shape used by the assembler.
 
 | Pseudo | Accepted format | Expansion (conceptual) | Notes |
 | --- | --- | --- | --- |
@@ -202,11 +201,11 @@ The table below documents the pseudo forms implemented by Falcon and the exact e
 > `jal` and `jalr` are real ISA instructions (not pseudos) and are also supported directly.
 > `jal` accepts both `jal label` (implicit `rd=ra`) and `jal rd, label`.
 
-If you want to inspect the final expansion in practice, assemble with `cargo run` and check the decoded instruction trace in the run view.
+If you want to inspect the final expansion in practice, assemble with `cargo run` and check the decoded instruction trace in the RAVEN run view.
 
 ## Syscalls you can try
 
-Falcon supports a tiny Linux-style ABI plus a few Falcon-only teaching extensions.
+RAVEN supports a tiny Linux-style ABI plus a few RAVEN-only teaching extensions.
 
 ### ABI (Linux-style)
 
@@ -221,13 +220,13 @@ Falcon supports a tiny Linux-style ABI plus a few Falcon-only teaching extension
 3) Execute `ecall`.
 4) Read the return value from `a0`.
 
-Falcon currently supports a very small set. When a syscall is not implemented, Falcon stops execution and prints a message in the
+RAVEN currently supports a very small set. When a syscall is not implemented, RAVEN stops execution and prints a message in the
 console so the failure is obvious during teaching.
 
 #### Return values and errors
 
 - On success, the syscall returns a non-negative value in `a0` (for example, bytes read/written).
-- On error, Falcon uses Linux-style `-errno` in `a0`. Internally that is stored as `u32` (because registers are `u32`):
+- On error, RAVEN uses Linux-style `-errno` in `a0`. Internally that is stored as `u32` (because registers are `u32`):
   `a0 = (-(errno as i32)) as u32`.
 
 ### Linux syscalls (supported subset)
@@ -244,7 +243,7 @@ console so the failure is obvious during teaching.
 
 Arguments:
 
-- `a0 = fd` (Falcon supports `1` (stdout) and `2` (stderr), both show up in the console for now)
+- `a0 = fd` (RAVEN supports `1` (stdout) and `2` (stderr), both show up in the console for now)
 - `a1 = buf` (pointer to bytes in memory)
 - `a2 = count` (how many bytes to write)
 
@@ -257,7 +256,7 @@ Short example (prints "Hello!\n" and exits):
 ```asm
 .data
 msg: .ascii "Hello!"
-.byte 10          # '\n' (Falcon does not parse escape sequences inside .ascii/.asciz)
+.byte 10          # '\n' (RAVEN does not parse escape sequences inside .ascii/.asciz)
 
 .text
     li a0, 1       # fd=stdout
@@ -275,7 +274,7 @@ msg: .ascii "Hello!"
 
 Arguments:
 
-- `a0 = fd` (Falcon supports `0` only: stdin)
+- `a0 = fd` (RAVEN supports `0` only: stdin)
 - `a1 = buf` (pointer where bytes will be written)
 - `a2 = count` (maximum bytes to read)
 
@@ -285,8 +284,8 @@ Return:
 
 Important notes (teaching simplifications):
 
-- Input is line-based via the UI console. When a line is available, Falcon appends a final `\n` and serves it as bytes.
-- If there is no input yet, Falcon pauses execution (PC does not advance) and waits for the user to provide input in the UI.
+- Input is line-based via the UI console. When a line is available, RAVEN appends a final `\n` and serves it as bytes.
+- If there is no input yet, RAVEN pauses execution (PC does not advance) and waits for the user to provide input in the UI.
 
 Short example (read and echo back):
 
@@ -323,19 +322,19 @@ Effect:
 
 - Stops the VM “normally” (this is not a fault in the UI).
 
-### Falcon extensions (used by pseudos)
+### RAVEN extensions (used by pseudos)
 
 | `a7` | Name | Used by |
 | --- | --- | --- |
-| `1000` | `falcon_print_int` | `print rd` |
-| `1001` | `falcon_print_zstr` | `printStr` / `printString` |
-| `1002` | `falcon_print_zstr_ln` | `printStrLn` |
-| `1003` | `falcon_read_line_z` | `read label` |
-| `1010` | `falcon_read_u8` | `readByte label` |
-| `1011` | `falcon_read_u16` | `readHalf label` |
-| `1012` | `falcon_read_u32` | `readWord label` |
-
-For the Falcon `read*` extensions, Falcon keeps asking until a valid value fits in the requested size. Invalid input results in a friendly
+| `1000` | `raven_print_int` | `print rd` |
+| `1001` | `raven_print_zstr` | `printStr` / `printString` |
+| `1002` | `raven_print_zstr_ln` | `printStrLn` |
+| `1003` | `raven_read_line_z` | `read label` |
+| `1010` | `raven_read_u8` | `readByte label` |
+| `1011` | `raven_read_u16` | `readHalf label` |
+| `1012` | `raven_read_u32` | `readWord label` |
+
+For the RAVEN `read*` extensions, RAVEN keeps asking until a valid value fits in the requested size. Invalid input results in a friendly
 error message and the program counter does **not** advance, making it clear that execution is paused.
 
 Ready for a deeper dive? Revisit the [Tutorial](Tutorial.md) for hands-on assembly walkthroughs, or explore the sample programs in

docs/format.pt-BR.md

@@ -1,6 +1,6 @@
-# Guia de formato do Falcon ASM — RV32I em linguagem direta
+# Guia de formato do RAVEN — RV32I em linguagem direta
 
-Este é o guia de bolso do Falcon ASM, nosso emulador RISC-V pensado para ensino. Use-o como referência rápida.
+Este é o guia de bolso do RAVEN, nosso emulador RISC-V pensado para ensino. Use-o como referência rápida.
 
 ## Como aproveitar este documento
 
@@ -11,18 +11,17 @@ Este é o guia de bolso do Falcon ASM, nosso emulador RISC-V pensado para ensino
 
 ## Visão rápida da arquitetura
 
-O Falcon foca no subconjunto RV32I+M para que você entenda cada etapa do ciclo buscar → decodificar → executar sem distrações.
+O RAVEN foca no subconjunto RV32I+M para que você entenda cada etapa do ciclo buscar → decodificar → executar sem distrações.
 
 - **Tamanho da palavra:** 32 bits.
 - **Endianness:** sempre little-endian (`{to,from}_le_bytes`).
 - **Program counter:** avança 4 em cada instrução; desvios e saltos usam deslocamentos relativos ao PC.
 - **Registradores:** nomes `x0…x31` com os apelidos tradicionais `zero`, `ra`, `sp`, `gp`, `tp`, `t0…t6`, `s0/fp`, `s1`, `a0…a7`,
   `s2…s11`. Escritas em `x0/zero` são descartadas.
 
-Ainda não implementados: instruções CSR/FENCE e qualquer extensão de ponto flutuante. Manter o escopo pequeno torna o Falcon mais
-amigável para aulas e oficinas.
+Ainda não implementados: instruções CSR/FENCE. O RAVEN cobre RV32IMF — inteiros base, multiplicação/divisão e ponto flutuante de precisão simples.
 
-## Conjunto de instruções presente no Falcon
+## Conjunto de instruções presente no RAVEN
 
 | Categoria | Instruções |
 | --- | --- |
@@ -40,7 +39,7 @@ do resultado “arquitetado”. A interrupção evidencia que algo inesperado oc
 <a id="tabelas-de-codificacao"></a>
 ## Tabelas de codificação
 
-As tabelas abaixo mostram todos os layouts de 32 bits usados no Falcon. Sempre que aparecer uma observação, ela lembra o alcance
+As tabelas abaixo mostram todos os layouts de 32 bits usados no RAVEN. Sempre que aparecer uma observação, ela lembra o alcance
 do imediato ou algum detalhe importante.
 
 ### Tipo R (aritmética, lógica, multiplicação/divisão)
@@ -162,21 +161,21 @@ do imediato ou algum detalhe importante.
 
 **`JALR` (`0x67`):** usa `funct3 = 0x0`.
 
-**System (`0x73`):** o Falcon implementa dois códigos: `ECALL` (`0x00000073`) e `EBREAK` (`0x00100073`). O assembler aceita
+**System (`0x73`):** o RAVEN implementa dois códigos: `ECALL` (`0x00000073`) e `EBREAK` (`0x00100073`). O assembler aceita
 `halt` como alias de `ebreak`.
 
 <a id="comportamento-do-assembler-e-pseudoinstrucoes"></a>
 ## Comportamento do assembler e pseudoinstruções
 
-O assembler do Falcon é propositalmente simples para que você consiga acompanhar cada etapa:
+O assembler do RAVEN é propositalmente simples para que você consiga acompanhar cada etapa:
 
 - Comentários começam com `;` ou `#`.
 - Operandos são separados por vírgula (`mnemonic op1, op2, ...`).
 - Seções/diretivas suportadas incluem `.text`, `.data`, `.bss`, `.section`, `.word`, `.byte`, `.half`, `.ascii`, `.asciz`/`.asciiz`, `.space` e `.align`.
 
 ### Referência de pseudoinstruções
 
-A tabela abaixo documenta os formatos aceitos no Falcon e a forma exata (conceitual) de expansão usada pelo assembler.
+A tabela abaixo documenta os formatos aceitos no RAVEN e a forma exata (conceitual) de expansão usada pelo assembler.
 
 | Pseudo | Formato aceito | Expansão (conceitual) | Observações |
 | --- | --- | --- | --- |

docs/syscalls.md

@@ -1,6 +1,6 @@
-# FALCON — Syscall Reference
+# RAVEN — Syscall Reference
 
-FALCON uses the **Linux RISC-V ABI** calling convention for `ecall`.
+RAVEN uses the **Linux RISC-V ABI** calling convention for `ecall`.
 
 ```
 a7  = syscall number
@@ -43,7 +43,7 @@ a0  = return value  (negative value = -errno as u32)
 
 ### Manual heap — bump allocator pattern
 
-FALCON has **no `malloc`/`free`**. The free region between `bss_end` and the
+RAVEN has **no `malloc`/`free`**. The free region between `bss_end` and the
 stack bottom is plain RAM. To allocate dynamically, keep a pointer in `.data`
 and advance it manually:
 
@@ -64,7 +64,7 @@ alloc:
 
 The heap grows **upward** (toward higher addresses), while the stack grows
 **downward**. They will collide if the combined allocation exceeds free space —
-FALCON does not detect this; a memory fault or silent data corruption will occur.
+RAVEN does not detect this; a memory fault or silent data corruption will occur.
 
 ```
                     bss_end
@@ -132,7 +132,7 @@ Write bytes from a buffer to a file descriptor.
 | `a2`     | byte count |
 | **`a0` (ret)** | bytes written, or `-errno` |
 
-**Restrictions:** only `fd=1` and `fd=2` are supported (both go to the FALCON console).
+**Restrictions:** only `fd=1` and `fd=2` are supported (both go to the RAVEN console).
 
 ```asm
 .data
@@ -195,7 +195,7 @@ rng_buf: .space 4
 
 ## Falcon teaching extensions (syscall 1000+)
 
-These are FALCON-specific syscalls designed for classroom use. They are higher
+These are RAVEN-specific syscalls designed for classroom use. They are higher
 level than the Linux ABI equivalents and need no strlen loop or fd argument.
 
 ### `1000` — print integer
@@ -324,7 +324,7 @@ Parse one integer from stdin (range 0..4294967295) and store it as a `u32` (litt
 
 ## Error codes
 
-| Code | POSIX name | Meaning in FALCON |
+| Code | POSIX name | Meaning in RAVEN |
 |------|-----------|-------------------|
 | `-5`  | `EIO`    | getrandom OS failure |
 | `-9`  | `EBADF`  | unsupported fd |

docs/syscalls.pt-BR.md

@@ -1,6 +1,6 @@
-# FALCON — Referência de Syscalls
+# RAVEN — Referência de Syscalls
 
-O FALCON usa a convenção de chamada **Linux RISC-V ABI** para `ecall`.
+O RAVEN usa a convenção de chamada **Linux RISC-V ABI** para `ecall`.
 
 ```
 a7      = número da syscall
@@ -43,7 +43,7 @@ a0      = valor de retorno  (valor negativo = -errno como u32)
 
 ### Heap manual — padrão bump allocator
 
-O FALCON **não tem `malloc`/`free`**. A região livre entre `bss_end` e o fundo da
+O RAVEN **não tem `malloc`/`free`**. A região livre entre `bss_end` e o fundo da
 pilha é RAM comum. Para alocar memória dinamicamente, guarde um ponteiro em `.data`
 e avance-o manualmente:
 
@@ -63,7 +63,7 @@ alloc:
 ```
 
 O heap cresce para **cima** (endereços crescentes), enquanto a pilha cresce para
-**baixo**. Eles colidirão se a alocação combinada exceder o espaço livre — o FALCON
+**baixo**. Eles colidirão se a alocação combinada exceder o espaço livre — o RAVEN
 não detecta isso; ocorrerá uma falha de memória ou corrupção silenciosa de dados.
 
 ```
@@ -132,7 +132,7 @@ Escreve bytes de um buffer para um descritor de arquivo.
 | `a2`       | quantidade de bytes |
 | **`a0` (ret)** | bytes escritos, ou `-errno` |
 
-**Restrições:** somente `fd=1` e `fd=2` são suportados (ambos vão para o console do FALCON).
+**Restrições:** somente `fd=1` e `fd=2` são suportados (ambos vão para o console do RAVEN).
 
 ```asm
 .data
@@ -195,7 +195,7 @@ rng_buf: .space 4
 
 ## Extensões de ensino Falcon (syscall 1000+)
 
-Estas são syscalls exclusivas do FALCON, projetadas para uso em sala de aula. São
+Estas são syscalls exclusivas do RAVEN, projetadas para uso em sala de aula. São
 mais simples que os equivalentes Linux ABI e não precisam de loop strlen nem
 argumento fd.
 
@@ -327,7 +327,7 @@ Lê um inteiro da entrada (faixa 0..4294967295) e armazena como `u32` (little-en
 
 ## Códigos de erro
 
-| Código | Nome POSIX | Significado no FALCON |
+| Código | Nome POSIX | Significado no RAVEN |
 |--------|-----------|----------------------|
 | `-5`   | `EIO`     | falha do SO em getrandom |
 | `-9`   | `EBADF`   | fd não suportado |