se pronuncia coffe

Menos código. Mais intenção. JVM, nativo, script e web. Tudo partindo da mesma linguagem.

O mascote da Kof é uma civetta — também conhecida como gato do almiscar, é um felino que come café. Nada mais adequado para uma linguagem que se pronuncia coffe.

A linguagem Kof não possui qualquer relação com o jogo The King of Fighters ou com sua franquia.

O nome Kof surgiu como uma referência à palavra "coffee" escrita propositalmente de forma incorreta. A escolha foi feita justamente na tentativa de criar um nome curto, único e facilmente identificável para a linguagem.

Koflang e Kof4J não compactuam com a associação do nome à franquia The King of Fighters. Qualquer semelhança ou associação feita nesse sentido é incidental e não representa a origem, o propósito ou a identidade dos projetos.

Nosso objetivo sempre foi criar uma identidade própria para a linguagem e seus componentes.

Algumas pessoas olham para um problema e escrevem uma biblioteca.

Outras escrevem um framework.

Algumas criam uma ferramenta.

Eu aparentemente olhei para o ecossistema inteiro e pensei:

"Tá tudo complicado demais. Vou criar uma linguagem."

E, aparentemente, uma linguagem só também não era suficiente.

Bem-vinda à Kof.

Kof é uma linguagem de programação geral, fortemente tipada e estaticamente tipada, construída com uma ideia central:

Uma única linguagem não deveria obrigar você a escolher um único mundo.

Kof possui seu próprio compilador, lexer, parser, sistema de tipos, análise semântica e representação intermediária (Kof IR). A partir dessa IR, diferentes backends transformam o mesmo programa em diferentes formas de execução:

                         KOF
                          │
                    Kof Compiler
                          │
                       Kof IR
                          │
          ┌───────────────┼────────────────┐
          │               │                │
       JVM Backend    Native Backend    JS Backend
          │               │                │
          ▼               ▼                ▼
        JVM          Native Binary      ES Modules
       (.class)      (ELF x86_64,       (GraalJS /
                      riscv64/aarch64,    browser)
                      KofC, KofScript)

A linguagem não muda. O target muda.

Kof não funciona assim:

Kof → Java → javac → JVM

Funciona assim:

Kof → Kof Compiler → Kof IR → Backend → Target

O compilador possui sua própria implementação de:

• lexer
• parser
• AST
• resolução de símbolos
• sistema de tipos
• análise semântica
• IR
• diagnostics
• geração de código

Kof não depende de Java como linguagem intermediária.

Kof está em desenvolvimento ativo — 0.2.6-beta (02/09/2026).

O compilador possui frontend próprio, type system, Kof IR e sete targets: JVM (V21 via ASM), Native x86_64 (ELF, sem libc), native.risc/native.arm (toolchain + qemu), KofJS (ES Modules no GraalJS), KofScript (REPL) e KofC (subset C → nativo).

Concorrência: spawn tarefa() / val r = spawn f(); await r — virtual threads na JVM, pthread_create no Native (CONC001 fechado 31/08), sequencial no JS (CONC003). Ver docs/concurrency.md.

Null safety: String?/Int? + if (x != null) narrowing nos 3 targets (fix JVM 02/09). Map.get devolve V? para valores de referência.

Testes: test "nome" { } + assert(cond, "msg") + kof test — 810 testes (793 kof-compiler + 8 kof-script + 5 kof-c-compiler + 4 kof-cli). Ver learn/23-testing.md.

Depuração: kof debug <file.kf> — servidor DAP sobre stdio com JDWP cru (breakpoints por linha Kof, call stack com funções/linhas Kof, continue, disconnect). Ver docs/debugging.md.

Auditoria do ecossistema: matriz de cobertura da stdlib (inventário, gaps G1-G12, prioridade e estratégia) em docs/ecosystem-coverage.md. Plano de evolução para plataforma completa: docs/plan-platform-completion.md.

A fundação da UI do Kof: Color (RGBA 32-bit), Palette (cores nomeadas) e Theme (light/dark com cores semânticas) — mesma semântica em JVM, Native e JS. A renderização é KofJS: widgets → DOM real no webview nativo (bin/kof-webview, WebKitGTK embutido) ou no browser.

Widgets: Window (título, bind, show/close, size, theme), Label (text, fontSize, bold, color), Button (texto + ação por lambda com capturas), Input (text), containers Column/Row, View+Style (background, padding, radius).

class App {
    static Int count = 0
}

main() {
    var w = Window("Contador")
    var label = Label("contagem: 0")
    w.bind(label)
    w.bind(Button("+1", () -> {
        App.count = App.count + 1
        label.text = "contagem: " + App.count
    }))
    w.show()
}

kof run contador.kf --target=js   # abre a janela; fechar encerra o programa

Ver: learn/35-kof-ui.md e learn/37-kofjs.md.

Regra prática: docs/ diz como o Kof é (estado e arquitetura); learn/ ensina como usar o Kof (passo a passo); training/ alimenta quem gera código Kof (LLMs).

Aplicações web sem Spring, sem servlet container, sem annotations:

record User(String name, Int age)

main() {
    var app = web.app()

    app.use {
        if (header("x-auth") == "secret") {
            return null
        }
        return "{\"error\": \"unauthorized\"}"
    }

    app.get("/hello") {
        return "Hello from Kof"
    }

    app.get("/users/:id") {
        return "user " + param("id") + " q=" + query("name")
    }

    app.post("/user") {
        var user = json.decode<User>(body())
        return json.encode(user)
    }

    app.listen(8080)
}

kof serve app.kf

Path params, query, headers, body, middleware, JSON tipado e servidor HTTP embutido no runtime do programa. Ver: docs/stdlib-web.md.

Arquivos, diretórios e caminhos com uma API única em todos os targets:

var path = Path("data/users.txt")
path.parent().createDirectories()
path.writeText("Mel\nKof\n")
println(path.readText())
println(path.size())

var dir = Directory("data")
dir.createDirectories()
for (var entry in dir.list()) {
    println(entry.name)
}

Texto sempre UTF-8; bytes como Int[]; ausência como String? (null) e size() lança em vez de sentinela -1. Ver: learn/34-file-system.md e docs/stdlib/IO.md.

Kof é uma distribuição: instale e receba compilador, CLI, runtime, stdlib, tooling, editor support e um OpenJDK embutido. Nenhuma instalação externa de Java é necessária — e não precisa saber a versão para instalar.

1. Baixe o pacote do seu sistema em GitHub Releases: linux-x86_64.tar.gz / macos-arm64.tar.gz / windows-x86_64.zip.
2. Extraia e adicione o bin ao PATH:

# Linux
tar -xzf kof-*-linux-x86_64.tar.gz
export PATH="$PWD/$(ls -d kof-*-linux-x86_64 | head -1)/bin:$PATH"

# macOS (Apple Silicon)
tar -xzf kof-*-macos-arm64.tar.gz
export PATH="$PWD/$(ls -d kof-*-macos-arm64 | head -1)/bin:$PATH"

# Windows (PowerShell)
Expand-Archive .\kof-*-windows-x86_64.zip
$DIR = (Get-ChildItem -Directory -Filter "kof-*-windows-x86_64" | Select-Object -First 1).FullName
$env:PATH = "$DIR\bin;$env:PATH"

3. Confira:

kof version   # kof <versão da release>
kof info      # ambiente completo (JVM embutida, Tooling API 21, targets)

Ver: docs/distribution/INSTALL.md (guia completo com cada sistema, checksum e solução de problemas) e docs/distribution/ARCHITECTURE.md.

kof build <dir> [--target jvm|native|native.risc|native.arm|js|android] [--output <dir>] [--release]
kof run <file.kf> [--target jvm|native|native.risc|native.arm|js] [args...]
kof serve <file.kf> [--port <port>] [--host <host>]
kof check <file.kf|dir>
kof test <file.kf|dir> [--target jvm|native|js]
kof script | repl | c | fmt | config
kof bench | profile | inspect | debug
kof info | lsp | install | version

kof fmt (formatter idempotente) e kof config gen implementados — ver docs/tooling/README.md.

Requisitos: JDK 21+ (Temurin recomendado — é a Tooling API baseline) e Maven 3.9+. Para o target native: as/ld (binutils). O target js não exige nada externo (GraalJS embarcado no jar).

# 1. Compilar tudo (compilador, runtime, CLI com GraalJS embarcado)
mvn clean package -DskipTests

# 2. Rodar a suíte completa (JVM + Native + KofJS E2E)
mvn test

# 3. Usar direto do source (dev build, java do sistema)
mkdir -p lib
cp kof-cli/target/kof-cli-$(cat VERSION).jar lib/kof.jar
bin/kof version
bin/kof info

# 4. Instalar num prefixo (instalação local completa)
bin/kof install ~/.kof
export PATH="$HOME/.kof/bin:$PATH"
kof version

# 5. Empacotar a distribuição oficial (com OpenJDK 21 embutido)
scripts/package.sh --jdk      # gera dist/kof-<versão>-<os>-<arch>.tar.gz

O kof install <dir> copia o kof.jar para <dir>/lib/ e gera o launcher <dir>/bin/kof (usa o JDK embutido de <dir>/jdk/ quando presente; senão o java do sistema). O scripts/package.sh --jdk baixa o Temurin 21 do Adoptium e monta o layout completo de distribuição.

Versionamento centralizado em VERSION — ver docs/distribution/VERSIONING.md.

Windows: use o Git Bash para scripts/package.sh — o bash genérico do PATH pode resolver para o WSL e gerar uma distribuição Linux (OBS-005). No Windows, o Python pode estar disponível apenas como o launcher py — o script o descobre automaticamente (python3/python/ py -3).

Source (.kf)
  ↓ Lexer
  ↓ Parser
  ↓ AST
  ↓ Type System
  ↓ Semantic Analysis
  ↓ Kof IR (backend-agnostic)
  ├── JVM Backend (ASM) → .class
  ├── Native Backend (x86_64 / riscv64 / aarch64) → ELF
  └── JS Backend (GraalJS) → ES Modules

1. Menos código, mesma capacidade
2. Tipagem forte
3. Intenção acima de cerimônia
4. Um frontend, múltiplos backends
5. Direto para o target
6. Interoperabilidade
7. Sem mágica desnecessária
8. Ferramentas importam

Kof é orientada à intenção — o que não é um paradigma formal, e sim a orientação a objetos levada ao extremo: o código expressa o que quer, e a plataforma (linguagem + compilador + runtime + stdlib) decide como, por target e por convenção.

intenção → Kof → compilador → backend

Você escreve spawn tarefa() (não Thread), app.get("/users/:id") (não servlet container), Window/Button("+1", () -> ...) (não WebView/JavaFX), json.decode<User>(body) (não parser manual), Palette.red (não 0xFF0000FF). Se é essencial para qualquer programa, pertence à plataforma.

Quando um target não consegue realizar a intenção, ele diz isso em compile-time com um código de gap (CONC001, JSN002, ...) — nunca silenciosamente.

Detalhes: docs/philosophy.md · idiomas: training/idioms/ · anti-padrões: training/anti-patterns/.

• Java com outra sintaxe.
• Kotlin 2.
• Julia para JVM.
• Um transpiler.
• Um gerador de Java.
• Um interpretador fantasiado de compilador.

Kof é uma linguagem. Um compilador. Uma IR. Vários backends.

Kof é software livre distribuído sob a licença GNU General Public License v3.0.

Isso se aplica ao código-fonte do compilador, ferramentas e demais componentes do projeto.

Programas escritos em Kof NÃO são automaticamente GPLv3.

O autor do programa mantém o direito de escolher a licença do próprio software. Usar o compilador Kof não obriga ninguém a abrir seu código-fonte.

Software proprietário escrito em Kof é permitido, desde que respeite as licenças das dependências que efetivamente incorporar.

Para mais detalhes, consulte docs/LICENSING.md.

Kof

Uma linguagem. Um compilador. Vários mundos.

Menos cerimônia. Mais intenção.