Instalacao

Instale via npm — a maneira mais facil de comecar.

npm (Multi-plataforma)

Requires Node.js. Funciona no Windows, Linux e macOS.

Bash

npm install -g xanascript
xs run app.xs

VS Code Extension

Syntax highlight, snippets, LSP integrado. Veja no GitHub.

Bash

git clone https://github.com/xanascr/xs-vscode.git
cd xs-vscode
npm install -g vsce
vsce package
code --install-extension xanascript-*.vsix

Exemplos

Codigos de exemplo em xs-examples.

Bash

git clone https://github.com/xanascr/xs-examples.git
cd xs-examples
xs run hello.xs
xs run server.xs

Comandos

xs run app.xsExecutar

xs check app.xsVerificar

xs build app.xsBuild JS

xs build --optJS otimizado

xs build --wasmWebAssembly

xs build --standaloneJS unico + runtime

xs test .Rodar testes

xs dev app.xsHot reload

xs replInterativo

xs lspLanguage Server

xs fmt app.xsFormatar

xs docs src/ docs/Docs HTML

xs init meu-appNovo projeto

xs install pacoteInstalar pacote

xs publishPublicar

xs benchBenchmark

Sintaxe Completa

Toda keyword e portugues claro. O codigo se explica sozinho.

Variaveis e Tipos

XS

CRIA x = 10                       // mutavel
CRIA nome: TEXTO = "Joao"        // type hint
CRIA ativo: BOOLEANO = VERDADEIRO
x += 5                              // += -= *= /= %=

Tipo	Exemplo
`NUMERO`	`42`, `3.14`
`TEXTO`	`"ola"`
`BOOLEANO`	`VERDADEIRO`/`FALSO`
`NULO`	`NULO`
`[ ]`	`[1, 2, 3]`
`{ }`	`{ nome: "Joao" }`

Funcoes

XS

CHAMA ESSE CARA soma(a, b) {
  VOLTA a + b
}

CRIA quadrado = (x) => x * x

CRIA fetch = ASSINCRONO (url) => {
  VOLTA AGORA VAI(url)
}

CRIA r = soma(3, 4)  // r = 7

CHAMA ESSE CARA declara funcoes. VOLTA retorna. Arrow functions com =>. ASSINCRONO para async.

EXPORTA torna a funcao disponivel para outros modulos via IMPORTA.

Controle de Fluxo

XS

SE LIGA SO (idade >= 18) {
  SOLTA O GRITO("Maior")
} SENAO SE LIGA SO (idade >= 12) {
  SOLTA O GRITO("Adolescente")
} SENAO {
  SOLTA O GRITO("Crianca")
}

REPETE NA MORAL (CRIA i = 0; i < 5; i++) {
  SOLTA O GRITO(i)
}

REPETE AI (condicao) { ... }

VOA()       // break
CONTINUA()  // continue

SE LIGA SO / SENAO SE LIGA SO / SENAO para condicionais.

REPETE NA MORAL = for. REPETE AI = while.

VOA() = break. CONTINUA() = continue.

Classes e OOP

XS

CLASSE Animal {
  CONSTRUTOR(nome) {
    CRIA ISTO.nome = nome
  }
  METODO falar() {
    SOLTA O GRITO(ISTO.nome + " faz barulho")
  }
}

CLASSE Cachorro HERDA Animal {
  METODO falar() {
    SOLTA O GRITO(ISTO.nome + " faz: Au au!")
  }
}

CRIA rex = NOVA Cachorro("Rex")
rex.falar()

CLASSE, HERDA, CONSTRUTOR, METODO, ISTO (this), NOVA (new).

Heranca simples com HERDA. Metodos sao declarados com METODO.

Switch / Pattern Matching

XS

ESCOLHE (dia) {
  CASO 1:
    SOLTA O GRITO("Domingo")
  CASO 2:
  CASO 3:
    SOLTA O GRITO("Inicio da semana")
  PADRAO:
    SOLTA O GRITO("Outro")
}

CRIA res = COMBINA (valor) {
  CASO 0 => "zero"
  CASO [a, b] => "array de 2"
  CASO { nome } => nome
  CASO _ => "outro"
}

ESCOLHE/CASO/PADRAO — switch tradicional com fallthrough.

COMBINA — pattern matching estilo Rust. Desestrutura arrays, objetos. _ e wildcard.

Mais Recursos

Template Strings

XS

CRIA nome = "XanaScript"
SOLTA O GRITO(`Bem-vindo ao ${nome}!`)

Try / Catch

XS

TENTA {
  CRIA r = PARSEIA("json")
} PEGA (erro) {
  SOLTA O GRITO("Deu ruim:", erro)
}

Destructuring + Spread

XS

CRIA [a, b] = [1, 2]
CRIA clone = [...lista, 6]
CRIA r = pessoa?.endereco ?? "N/A"

Modulos

XS

// math.xs
EXPORTA soma
CHAMA ESSE CARA soma(a, b) { VOLTA a + b }

// main.xs
IMPORTA "./math.xs"
SOLTA O GRITO(soma(2, 3))

IMPORTA "./math.xs" as m
SOLTA O GRITO(m.soma(2, 3))

Operadores

XS

a + b   a - b   a * b   a / b   a % b
a == b  a != b  a > b   a < b   a >= b  a <= b
a && b  a || b  !a
a ? b : c                              // ternario
"hello" ~= "^h.*o$"                // regex
x += 1   x -= 1   x *= 2

Built-ins

XS

SOLTA O GRITO("log")       // console.log
AGORA VAI(url)              // HTTP GET
ESPERA AI(1000)              // sleep
SORTEIA(1, 10)                // aleatorio
PARSEIA(json)               // JSON.parse
TAMANHO(array)              // length
CRIA SERVIDOR(3000, handler) // HTTP server

Por que XanaScript?

Uma linguagem que nao tem medo de ser diferente — e extremamente capaz.

Sintaxe em Portugues

CRIA, SE LIGA SO, REPETE NA MORAL — codigo que qualquer brasileiro entende de primeira.

JS Ultra-Otimizado

TypedArrays automaticos, integer hints, loop unrolling, constant folding. Gera JS mais rapido que codigo manual.

WebAssembly Nativo

Compila direto pra .wasm — sem Emscripten, sem wabt.js. Emissor binario proprio.

ORM Embutido

TABELA Usuario { nome: TEXTO } → CRUD automatico. Zero configuracao, zero dependencias.

Macros Compile-Time

MACRO quadrado(x) { x * x } — expandido em tempo de compilacao. Zero custo em runtime.

Test Runner Nativo

TESTE "desc" { AFIRMA(x == 5) }. Descoberta automatica, output colorido, exit code pra CI.

LSP Completo

Autocomplete, erros em tempo real, hover, go-to-definition. VS Code, Neovim, qualquer editor LSP.

Gerenciador de Pacotes

xs install, xs publish. Pacotes via GitHub com fallback pra npm.

Erros estilo Rust

Erros com codigo fonte destacado, seta apontando o local exato, hint e help com sugestoes.

VS Code Extension

Syntax highlight, 18 snippets, LSP integrado, comandos Run (Ctrl+Alt+X), Build, Test, Format.

CLI Completa

REPL, formatador, watcher com hot reload, bytecode VM, benchmark, docs generator. 20+ comandos.

Task Runner

TAREFA build { } em tarefas.xs. Execute com xs build. Sem Makefile.

WebAssembly Nativo

XanaScript e a unica linguagem que compila direto pra .wasm sem dependencias externas.

XS

CHAMA ESSE CARA soma(a, b) {
  VOLTA a + b
}
CHAMA ESSE CARA main() {
  VOLTA soma(10, 20)
}

$ xs build --wasm math.xs

O modulo src/wasm_binary.js contem um emissor Wasm binario proprio que:

Pega a AST otimizada
Emite o formato binario Wasm diretamente (magic + versao + secoes)
Usa encoding LEB128 proprio
Gera opcodes i32: constantes, aritmetica, if/else, loops, funcoes

Zero dependencias. Sem Emscripten, sem wabt.js, sem AssemblyScript.

i32Inteiros 32-bit

+ - * / %Aritmetica

if/elseCondicionais

loopsFor / While

callChamadas

ORM Embutido

Declare uma tabela, ganhe CRUD automatico com armazenamento JSON local.

XS

TABELA Produto {
  nome: TEXTO,
  preco: NUMERO,
  estoque: NUMERO
}

CRIA repo = Produto
repo.criar({ nome: "Teclado", preco: 250, estoque: 10 })
repo.criar({ nome: "Mouse", preco: 120, estoque: 25 })

SOLTA O GRITO(repo.listar())       // todos
SOLTA O GRITO(repo.buscar(1))     // por ID
CRIA caros = repo.buscarOnde({ preco: 250 })
repo.atualizar(1, { nome: "Teclado RGB" })
repo.deletar(2)

Tipo	Descricao
`TEXTO`	string
`NUMERO`	number
`BOOLEANO`	boolean
`DATA`	string ISO
`QUALQUER`	any

.criar(dados)CREATE

.listar()READ ALL

.buscar(id)READ BY ID

.atualizar(id, dados)UPDATE

.deletar(id)DELETE

.buscarOnde(filtro)FILTER

.contar()COUNT

Cada tabela vira um arquivo JSON. IDs auto-incrementados com timestamps automaticos.

Macros Compile-Time

Codigo que gera codigo — expandido durante a compilacao, zero custo em runtime.

XS

MACRO quadrado(x) { x * x }
MACRO cubo(x) { x * quadrado(x) }
MACRO maior(a, b) {
  SE LIGA SO (a > b) { a } SENAO { b }
}
CRIA r1 = quadrado(5)      // -> 5*5 = 25
CRIA r2 = cubo(3)          // -> 27
CRIA r3 = maior(10, 20)    // -> 20
CRIA r4 = maior(quadrado(4), cubo(2))

Macros funcionam como #define em C, mas com sintaxe XanaScript:

O optimizer coleta todas as declaracoes MACRO
Cada chamada e substituida pelo corpo com parametros substituidos
Macros aninhadas sao expandidas recursivamente
Apos expansao, as declaracoes MACRO somem da AST

O resultado e codigo literal — sem overhead de chamada, sem closure.

Test Runner

Framework de testes integrado — sem Jest, sem Mocha, zero dependencias.

XS

TESTE "soma de dois numeros" {
  CRIA r = 2 + 3
  AFIRMA(r == 5)
  ASSUNTO(r, 5)
}
TESTE "multiplicacao" {
  CRIA r = 3 * 4
  ASSUNTO(r, 12)
}

$ xs test .

Arquivos com test no nome sao detectados recursivamente. AFIRMA para assert truthy, ASSUNTO para equal.

Output colorido com passou/falhou, tempo de execucao, exit code 1 em falha (CI/CD ready).

Output

  PASS soma de dois numeros
  PASS multiplicacao
  FAIL divisao por zero

  2 passaram  1 falhou  0.01s

LSP — Language Server Protocol

Autocomplete, erros em tempo real, hover e go-to-definition para qualquer editor compativel.

Inicie o servidor com xs lsp e conecte seu editor. Comunicacao via stdin/stdout usando JSON-RPC.

Bash

xs lsp

Neovim

Lua

vim.api.nvim_create_autocmd("FileType", {
  pattern = "xs",
  callback = function()
    vim.lsp.start({
      name = "xanascript",
      cmd = { "xs", "lsp" },
    })
  end,
})

Diagnosticos em tempo real

Autocomplete de keywords + built-ins

Hover com documentacao

Go-to-definition

VS Code

A extensao vscode-xs/ ja integra o LSP automaticamente ao abrir um arquivo .xs.

Ctrl+Alt+XRun

Ctrl+Alt+BBuild

Ctrl+Shift+FFormat

Erros estilo Rust

Codigo fonte destacado, seta apontando o local exato, hint e help com sugestoes de correcao.

XS

CRIA x = 10
CRIA y = z    // z nao foi definido

Error

ERROR: Variavel `z` nao foi definida
Code: E002

 --> input.xs:2:11

   1 | CRIA x = 10
 > 2 | CRIA y = z
     |          ^

Hint: Esqueceu de declarar "z" com CRIA?
Help: Adicione `CRIA z = valor` antes de usar

Codigo	Significado
`E001`	Token inesperado
`E002`	Variavel nao definida
`E003`	Nao e uma funcao
`E004`	Tipo incompativel
`E005`	Sintaxe invalida
`E100`	Falha HTTP
`E999`	Erro interno

XanaScript vs JavaScript / TypeScript

Uma linguagem que entrega o que JS/TS prometem — e muito mais.

Caracteristica	XanaScript	JavaScript	TypeScript
Sintaxe em PT-BR	Sim	Nao	Nao
Compilacao Wasm direta	Sim	Emscripten	AssemblyScript
ORM embutido	Sim	Nao	Nao
Macros compile-time	Sim	Nao	Nao
Pattern Matching	Sim	Nao	Nao
Loop Unrolling	Sim	Nao	Nao
TypedArrays automaticos	Sim	Nao	Nao
Integer Math Hints	Sim	Nao	Nao
Constant Folding	Sim	Nao	Nao
Erros estilo Rust	Sim	Nao	Nao
LSP	Sim	Nao	Sim
Test Runner nativo	Sim	Nao	Nao
Task Runner nativo	Sim	Nao	Nao
Classes/OOP	Sim	Sim	Sim
Template Strings	Sim	Sim	Sim
CLI Completa	20+ cmd	Node.js	tsc
Hot Reload	Sim	nodemon	ts-node
Standalone Binary	Sim	pkg/bun	pkg/bun
Bytecode VM	Sim	Nao	Nao
Built-ins nativas	Sim	Nao	Nao

Arquitetura

Como o codigo em portugues vira executavel de alta performance.

.xs Code

→

Lexer
lexer.js

→

Parser
parser.js

→

Optimizer
opt.js

↙ ↘

Runtime (interpreter)

and

Codegen

codegen.js (JS)

codegen_opt.js (JS++)

codegen_wasm.js (WAT)

wasm_binary.js (.wasm)

Roadmap

O que ja implementamos e o que esta por vir.

Implementado

Lexer + Parser + AST (loc tracking)

Erros estilo Rust (codigo + seta + hint)

Macros compile-time (MACRO)

ORM embutido (TABELA > CRUD)

LSP (autocomplete, hover, go-to-def)

Test runner (TESTE, AFIRMA, ASSUNTO)

Task runner (TAREFA)

Docs generator (xs docs)

Wasm binary emitter direto

VS Code Extension com LSP

Standalone CLI nativo (bun --compile)

Classes/OOP (CLASSE, HERDA, ISTO)

Pattern Matching (COMBINA)

Template Strings + Try/Catch

Modulos (IMPORTA, EXPORTA)

Servidor HTTP embutido

Bytecode VM (26 opcodes)

Gerenciador de pacotes

Proximos passos

Source maps completos (VLQ)

Classes com super()

Pattern matching com guards

Macros higienicas

Publicar VS Code Extension no Marketplace

Debugger (step, breakpoints)

XanaScript Playground

Instalacao

npm (Multi-plataforma)

VS Code Extension

Exemplos

Comandos

Sintaxe Completa

Variaveis e Tipos

Funcoes

Controle de Fluxo

Classes e OOP

Switch / Pattern Matching

Mais Recursos

Template Strings

Try / Catch

Destructuring + Spread

Modulos

Operadores

Built-ins

Por que XanaScript?

Sintaxe em Portugues

JS Ultra-Otimizado

WebAssembly Nativo

ORM Embutido

Macros Compile-Time

Test Runner Nativo

LSP Completo

Gerenciador de Pacotes

Erros estilo Rust

VS Code Extension

CLI Completa

Task Runner

WebAssembly Nativo

ORM Embutido

Macros Compile-Time

Test Runner

LSP — Language Server Protocol

Neovim

VS Code

Erros estilo Rust

XanaScript vs JavaScript / TypeScript

Arquitetura

Roadmap

Implementado

Proximos passos