Binários nativos
Compilação nativa de arquivos .tyr com LLVM e runtime integrado ao executável.

Linguagem backend compilada
Tyrus usa sintaxe concisa em arquivos .tyr e adiciona execução nativa, semântica de memória determinística com NLL, diagnósticos precisos e tooling focado em backend.
const main = () => {
print("Hello, World!");
};Superpoderes da linguagem
Regras embutidas como @email, @minLength e @min, além de validações customizadas com validator function. Validação declarativa sem boilerplate em runtime.
Execute lógica pura durante a compilação com comptime(...). Pré-compute tabelas de lookup, constantes e configurações com zero custo em runtime.
Criptografe o .env em target/<profile>/.env.sealed com impressões digitais binárias. O espelho .env.example é sincronizado automaticamente a cada mudança.
Inteiros e floats u8..u128, i8..i128, f32..f128, decimal, boolean, string, char e tipos Result<T, E> nativos.
Segurança determinística de memória
Segurança de memória sem garbage collector. Tipos que não são Copy movem por atribuição, enquanto empréstimos são validados em compilação. Com Non-Lexical Lifetimes (NLL), os empréstimos expiram após o último uso real, liberando variáveis para mutação imediata sem esperar o término do bloco.
const greeting: string = "hello";
const copy: string = greeting;
print(copy); // hello
print(greeting); // error: `greeting` was moved to `copy`Limpeza por escopo
defer executa quando o escopo termina. errdefer executa apenas quando um retorno opcional ou Result sai com erro, deixando o rollback explícito.
function transfer(ok: boolean): Result<void, string> {
defer print("cleanup"); // cleanup
errdefer print("rollback"); // rollback
if (!ok) {
return Err("transfer failed");
}
return Ok();
}
const main = (): void => {
match (transfer(false)) {
Ok() => print("transfer complete"); // transfer complete
Err(error) => printError(error); // transfer failed
}
};Pattern matching exaustivo
Unions marcadas, variantes de enums algébricos e match com guard clauses dão controle de fluxo exaustivo. O compilador garante que toda variante é tratada e estreita os tipos em cada ramo.
const main = () => {
const getLetterGrade = (score: u8): string => {
match (score) {
90..=100 => "A";
80..=89 => "B";
70..=79 => "C";
60..=69 => "D";
0..=59 => "F";
_ => "Invalid Score";
}
};
print(getLetterGrade(95)); // A
};Sem null. Sem undefined. Só T?
Um return; vazio produz ausência. ?. e ?? propagam de forma segura. O compilador força você a tratar o caso ausente antes que o valor chegue em produção, sem surpresas em runtime.
const findAccount = (id: i32): Account? => {
if (id > 0) {
return { id, nickname: "ada" };
}
return; // absence
};
const account: Account? = findAccount(1);
print(account?.nickname ?? "anon");
// Uninitialized optional starts empty
let pending: i32?;
print(pending ?? 0); // 0Sucesso e falha explícitos
Result.Result<T, E> contém um valor Ok ou um valor Err. Combine as duas variantes ou propague o erro com ?.
function lookupName(found: boolean): Result<string, string> {
if (found) {
return Ok("Ada");
}
return Err("user not found");
}
const main = (): void => {
match (lookupName(false)) {
Ok(name) => print(name);
Err(message) => printError(message); // user not found
}
};Tratamento de erros no ponto de chamada
onfail.Anexe um handler de erro ao inicializador de um Result. O handler recebe o erro, enquanto a variável contém o valor de sucesso quando a execução continua.
function lookupName(found: boolean): Result<string, string> {
if (found) {
return Ok("Ada");
}
return Err("user not found");
}
function showName(found: boolean): void {
const name = lookupName(found) onfail {
printError(name); // user not found
return;
};
print(name); // Ada
}
const main = () => showName(true);Operador pipe
O operador |> encadeia valores em cadeias de função. O token % permite posicionar o valor pipeado exatamente onde ele deve ficar, sem variáveis intermediárias, sem aninhamento.
const main = (): void => {
const double = (n: i64): i64 => n * 2;
const increment = (n: i64): i64 => n + 1;
const clamp = (value: i64, min: i64, max: i64): i64 => value < min ? min : value > max ? max : value;
// Pipe chains read top-to-bottom
const result: i64 = 5
|> double
|> increment
|> double; // 5 -> 10 -> 11 -> 22
// Topic token % places the piped value exactly
const clamped: i64 = 80 |> clamp(30, %, 100); // 80
print(clamped); // 80
};Código assíncrono nativo
Funções async retornam Promise<T>. Use await para ler o valor quando a operação assíncrona terminar.
async function loadName(): Promise<string> {
return "Ada";
}
async function main(): Promise<void> {
const name = await loadName();
print(`Hello, ${name}`); // Hello, Ada
}Kernels numéricos de alta performance
Os primitivos f32 e f64 fornecem algebraicAdd, algebraicSub, algebraicMul, algebraicDiv e algebraicRem. Eles concedem permissão explícita ao compilador para reassociar cálculos de ponto flutuante para vetorização SIMD e aceleração matemática em hardware.
const main = (): void => {
const left: f64 = 6.0;
const right: f64 = 4.0;
// Explicit compiler permission for fast-math reassociation:
const sum: f64 = left.algebraicAdd(right);
const diff: f64 = left.algebraicSub(right);
const prod: f64 = left.algebraicMul(right);
const quot: f64 = left.algebraicDiv(right);
const rem: f64 = left.algebraicRem(right);
print(prod); // 24.0
};Proteção de segredos em produção
A configuração security.envSealed criptografa o .env em target/<profile>/.env.sealed com chaves assimétricas e insere uma impressão digital no binário para que contêineres nunca exponham segredos em texto puro. Em desenvolvimento, o compilador espelha chaves e comentários em .env.example com valores limpos automaticamente.
{
"security": {
"envFile": ".env",
"envSealed": true
}
}# .env (local secrets) # .env.example (mirrored & committed)
@type(u16) @type(u16)
@port() @port()
PORT=8080 PORT=
@type(string) @type(string)
@startsWith("postgres://") @startsWith("postgres://")
DATABASE_URL=postgres://... DATABASE_URL=
@type(string) @type(string)
@minLength(16) @minLength(16)
API_SECRET=super_secret_value API_SECRET=ORM e ODM tipados
Defina Models como interfaces tipadas e consulte-os de forma assíncrona. A mesma API de Model funciona em bancos relacionais e MongoDB, com falhas recuperáveis retornadas em Result.
import { User } from "./models/User";
async function main(): Promise<void> {
const users = await User.findMany({ active: true });
}Avaliação em tempo de compilação
Funções declaradas com comptime executam durante a compilação e incorporam seu resultado como escalares ou literais estáticos diretamente no binário. Calcule tabelas de lookup, constantes matemáticas e configurações com tipagem completa.
comptime function fibonacci(index: i32): i64 {
let previous: i64 = 0;
let current: i64 = 1;
for (let pos: i32 = 0; pos < index; pos++) {
const next: i64 = previous + current;
previous = current;
current = next;
}
return previous;
}
// Evaluated once at compile time, zero runtime calculation:
const maxLimit: i64 = comptime(fibonacci(50));
const main = (): void => {
print(maxLimit); // 12586269025
};Exploração interativa
Explore o Tyrus instantaneamente sem configurar projetos. O tyrus repl fornece um console interativo com avaliação JIT via LLVM em processo, edição multilinha, persistência de sessões e inspeção com :type. Prefere o navegador? Abra o Web Playground em playground.tyruslang.org para escrever, compilar para WebAssembly e rodar código direto no navegador com links compartilháveis.
tyrus repl
______ ____ __________ __
/_ __/_ _________ _______ / __ \/ ____/ __ \/ /
/ / / / / / ___/ / / / ___/ / /_/ / __/ / /_/ / /
/ / / /_/ / / / /_/ (__ ) / _, _/ /___/ ____/ /___
/_/ \__, /_/ \__,_/____/ /_/ |_/_____/_/ /_____/
/____/
Type :help for available commands.
tyrus> :help
Commands (prefix with :):
:help Show this help
:clear Clear screen and session buffer
:load <file> Load and evaluate a .tyr file
:type <expr> Show the inferred type of an expression
:doc <symbol> Show documentation for a symbol
:edit Edit session buffer in external editor ($EDITOR)
:save <name.tyr> Save session buffer to ~/.tyrus/repl/<name>.tyr
:restore <name|file> [--merge|-m] Restore a saved session (resets first; --merge keeps the current buffer)
:delete <name> Delete a saved session from ~/.tyrus/repl
:list List sessions saved via :save (~/.tyrus/repl)
:reset Reset the entire session
:exit Exit the REPL
:quit Alias for :exit
:q Alias for :exit
Multi-line input is auto-detected by bracket matching.
tyrus>Uma toolchain de linguagem, não só um parser
tyrus repl para avaliação JIT via LLVM em processo, tyrus dev para live reload e tyrus fmt para formatação sem configuração.
Códigos de erro estáveis com tyrus explain, ranges precisos, mensagens de ajuda, exemplos de falha e Quick Fixes no editor.
Completion, hover, signature help, inlay hints, semantic tokens e code actions para VS Code, Neovim, Zed, IntelliJ e Kate.
Execute no navegador via WebAssembly em playground.tyruslang.org e rode suítes locais com tyrus test para arquivos *.test.tyr.
Formatação de código
tyrus fmt formata arquivos `.tyr` de maneira consistente e aplica as opções do tyrus-fmt.json do projeto.
tyrus-fmt.json
{
"indent_style": "spaces",
"indent_width": 4,
"line_width": 90,
"quote_style": "double"
}Análise de código
tyrus lint aponta problemas de estilo, correção, segurança, desempenho e arquitetura. Defina a severidade de cada regra em tyrus-lint.json no projeto.
tyrus-lint.json
{
"no-unused-vars": "warn",
"no-unused-imports": "warn",
"prefer-const": "warn",
"no-force-unwrap": "error"
}Baterias incluídas
Tudo o que é necessário para construir serviços backend resilientes, ferramentas de CLI e software de sistemas já faz parte do runtime do Tyrus.
Feedback de segurança enquanto você digita
Diagnósticos do compilador e do linter passam pela mesma análise usada pela CLI e pelo Language Server, então terminal e editor concordam sobre o que está errado e como corrigir.
error
const maxUsers: u32 = "100";
let retries: u32 = 3;
print(retries);error[E0308]: type mismatch for `maxUsers`: expected `u32`, found `string`
at /src/main.tyr:1:7
const maxUsers: u32 = "100";
^^^^^^^^
help: change the value or the annotation so their types match; convert numbers explicitly with `value as <type>`Comece com um comando
tyrus newExecute com um comando
tyrus runPor que esse nome
Tyrus é a grafia em latim de Tiro, a cidade fenícia cujo nome significa "rocha". Tyr é o deus da guerra, da justiça e da coragem na mitologia nórdica.
Mas o nome é a junção das iniciais de TypeScript e Rust.