Binarios nativos
Compilación nativa de archivos .tyr con LLVM y runtime integrado en el ejecutable.

Lenguaje backend compilado
Tyrus usa sintaxis concisa en archivos .tyr y agrega ejecución nativa, semántica de memoria determinística con NLL, diagnósticos precisos y tooling enfocado en backend.
const main = () => {
print("Hello, World!");
};Superpoderes del lenguaje
Reglas integradas como @email, @minLength y @min, más validaciones personalizadas con validator function. Validación declarativa sin boilerplate en runtime.
Ejecuta lógica pura durante la compilación con comptime(...). Precalcula tablas de búsqueda, constantes y configuraciones sin costo en runtime.
Cifra .env en target/<profile>/.env.sealed con huellas digitales binarias. El espejo .env.example se sincroniza automáticamente con cada cambio.
Enteros y floats u8..u128, i8..i128, f32..f128, decimal, boolean, string, char y tipos Result<T, E> nativos.
Seguridad determinística de memoria
Seguridad de memoria sin garbage collector. Los tipos que no son Copy se mueven por asignación, mientras que los préstamos se validan en compilación. Con Non-Lexical Lifetimes (NLL), los préstamos expiran después de su último uso real, liberando variables para mutación inmediata sin esperar el final del bloque.
const greeting: string = "hello";
const copy: string = greeting;
print(copy); // hello
print(greeting); // error: `greeting` was moved to `copy`Limpieza por ámbito
defer se ejecuta al salir del ámbito. errdefer se ejecuta solo cuando un retorno opcional o Result sale con error, haciendo explícita la reversión.
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 exhaustivo
Unions marcadas, variantes de enums algebraicos y match con guard clauses dan flujo de control exhaustivo. El compilador garantiza que cada variante se maneja y estrecha los tipos en cada brazo.
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
};Sin null. Sin undefined. Solo T?
Un return; vacío produce ausencia. ?. y ?? la propagan de forma segura. El compilador te obliga a manejar el caso ausente antes de que el valor llegue a producción, sin sorpresas en 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); // 0Éxito y fallo explícitos
Result.Result<T, E> contiene un valor Ok o un valor Err. Combina ambas variantes o propaga el error con ?.
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
}
};Gestión de errores en la llamada
onfail.Adjunta un handler de error al inicializador de un Result. El handler recibe el error, mientras que la variable contiene el valor exitoso si la ejecución continúa.
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
El operador |> enhebra valores a través de cadenas de funciones. El token % permite colocar el valor pipeado exactamente donde debe estar, sin variables intermedias, sin anidamiento.
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 asíncrono nativo
Las funciones async devuelven Promise<T>. Usa await para obtener el valor cuando termine la operación asíncrona.
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 alto rendimiento
Los primitivos f32 e f64 proporcionan algebraicAdd, algebraicSub, algebraicMul, algebraicDiv y algebraicRem. Otorgan permiso explícito al compilador para reasociar cálculos de punto flotante para vectorización SIMD y aceleración matemática en 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
};Protección de secretos en producción
La configuración security.envSealed cifra .env en target/<profile>/.env.sealed con claves asimétricas e inserta una huella digital en el binario para que los contenedores nunca expongan secretos en texto plano. En desarrollo, el compilador refleja claves y comentarios en .env.example con valores limpios automáticamente.
{
"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 y ODM tipados
Define modelos como interfaces tipadas y consulta de forma asíncrona. La misma API de Model funciona con bases de datos relacionales y MongoDB, y devuelve los errores recuperables en Result.
import { User } from "./models/User";
async function main(): Promise<void> {
const users = await User.findMany({ active: true });
}Evaluación en tiempo de compilación
Las funciones declaradas con comptime se ejecutan durante la compilación e incorporan su resultado como escalares o literales estáticos directamente en el binario. Calcula tablas de búsqueda, constantes matemáticas y configuraciones con seguridad de tipos 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
};Exploración interactiva
Explora Tyrus al instante sin configurar proyectos. tyrus repl proporciona una consola interactiva con evaluación JIT a través de LLVM en proceso, edición multilínea, persistencia de sesiones e inspección con :type. ¿Prefieres el navegador? Abre el Web Playground en playground.tyruslang.org para escribir, compilar a WebAssembly y ejecutar código directamente en el navegador con enlaces compartibles.
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>Una toolchain de lenguaje, no solo un parser
tyrus repl para evaluación JIT a través de LLVM en proceso, tyrus dev para live reload y tyrus fmt para formateo sin configuración.
Códigos de error estables con tyrus explain, rangos precisos, mensajes de ayuda, ejemplos de fallo y Quick Fixes en el editor.
Completion, hover, signature help, inlay hints, semantic tokens y code actions para VS Code, Neovim, Zed, IntelliJ y Kate.
Ejecuta en el navegador mediante WebAssembly en playground.tyruslang.org y corre suites locales con tyrus test para archivos *.test.tyr.
Formato del código
tyrus fmt formatea archivos `.tyr` de forma consistente y aplica las opciones de tyrus-fmt.json del proyecto.
tyrus-fmt.json
{
"indent_style": "spaces",
"indent_width": 4,
"line_width": 90,
"quote_style": "double"
}Análisis de código
tyrus lint informa problemas de estilo, corrección, seguridad, rendimiento y arquitectura. Configura la severidad de cada regla en tyrus-lint.json del proyecto.
tyrus-lint.json
{
"no-unused-vars": "warn",
"no-unused-imports": "warn",
"prefer-const": "warn",
"no-force-unwrap": "error"
}Baterías incluidas
Todo lo necesario para construir servicios backend resilientes, herramientas de CLI y software de sistemas ya forma parte del runtime de Tyrus.
Feedback de seguridad mientras escribes
Los diagnósticos del compilador y del linter pasan por el mismo análisis usado por la CLI y el Language Server, así que terminal y editor coinciden sobre qué está mal y cómo corregirlo.
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>`Empieza con un comando
tyrus newEjecuta con un comando
tyrus runPor qué este nombre
Tyrus es la grafia en latín de Tiro, la ciudad fenicia cuyo nombre significa "roca". Tyr es el dios de la guerra, la justicia y el coraje en la mitología nórdica.
Pero el nombre es la unión de las iniciales de TypeScript y Rust.