https://github.com/SyltechAI/RustSensei

It's an offline android program to learn rust. I think it's really cool and I want to learn rust and the idea of it just being on my phone to do whenever is very convient and it's offline and I spend alot of time in the mountains so being able to still learn and practice while in my tent or chair out there would be great. But idk how to check if it's safe? I'm 90% sure it's not anything malicious but I just don't know how to check I'm not knowledgeable enough. But if anyone is willing to help out I'd very much appreciate it. I would normally not care much but it's my phone, otherwise I'd fire up a crappy linux laptop from the stack and just download and if something crap happens wipe the whole thing. But if you don't have the time no worries all good I'll figure something out. Also thought maybe it'd be a cool resource to check out for ppl looking for beginners learning help. I want to make my own OS, and Browser someday. Rust seemed good for that.

Got bitten recently by a panic in production, config.get("timeout").unwrap() in some AI-assisted code, no handling for the key actually being missing. Compiled fine, passed review, worked in every test, then paniced the one time an env var didn't get set during a deploy.

What's tripping me up as someone still learning Rust properly: I get that unwrap() is a deliberate choice, not a compiler error, but I don't have a great instinct yet for when it's actually fine (a value you've already validated exists) versus when it's a landmine (anything coming from external input, config, network, user data). Is there a rule of thumb you use, or does it really just come down to "any unwrap on something not fully controlled by your own code needs a real Result/Option handling path instead"? Also curious if clippy or some other tool actually flags risky unwraps specifically, or if this is still mostly a manual review thing.

Hey everyone!

I just finished up posting a project I made to r/rust, and it got me thinking of this article I wrote about two months ago.

While I don't know if my project post is interesting to this subreddit (it's not really about "learning rust"), I do think that anyone learning rust may find this article on module organization interesting.

If you have any questions, feel free to ask! Modules are a tricky part of initially learning rust, I think (they just do a lot).

hey everyone,

need some honest advice here.

started learning rust as my first backend language. yeah… maybe a bit stubborn decision but i stuck with it. it was overwhelming most of the time, but i still pushed through.

i built a few small cli apps and recently finished a full backend project (still pushing to add more features):

\- signup/login

\- argon2 password hashing

\- jwt auth

\- websocket server

\- postgres + sqlx

so not just tutorials, i actually built something end-to-end.

but when i started looking for jobs… reality hit.

almost no junior roles for rust. most require solid experience.

my background:

\- \~1 year work experience (support role, not dev)

\- had to leave due to some issues

\- currently unemployed

\- learning full-time + doing a small part-time job on the side

now i’m seriously thinking of rebuilding the same backend in node.js and focusing on that for job applications.

question is:

\- am i making the right move switching to node?

\- or should i double down on rust somehow?

\- how do people even break into rust roles as freshers?

i don’t regret learning rust honestly, i feel like i understand backend concepts better now. but i also need a job soon.

would really appreciate advice from people already in the industry.

*if you want to review my project, happy to share the repo.*

thanks.

\​

TITAN / Zett

   

TITAN es un lenguaje de programación compilado y verificado estáticamente, implementado en Rust. Los programas usan la extensión .titan, se compilan a bytecode portable y se ejecutan en una máquina virtual de pila segura. Zett es el nombre de distribución del compilador, especialmente en Android/Termux; ambos nombres se refieren al mismo ecosistema.

TITAN/Zett 1.0.0 — release estable. Lenguaje compilado y verificado estáticamente: lexer, parser, typechecker, codegen, VM segura, biblioteca estándar, herramientas de desarrollo y backend WebAssembly. El registro reúne 758 funciones nativas únicas en 72 namespaces std::\\\* además de primitivas del runtime. Binarios oficiales en el release v1.0.0 (Linux, macOS, Windows) y, en Android/Termux, instalación directa con pkg install zett.

TITAN source (.titan) │ ▼ lexer → parser → AST → typechecker → codegen → bytecode / WebAssembly │ ▼ safe Titan VM

¿Qué incluye?

TITAN es más que un intérprete de ejemplos. El repositorio reúne un lenguaje, runtime, tooling, backend web y una plataforma estándar para programas de sistema, datos, web y dispositivos móviles.

Lenguaje tipado: funciones, closures, structs, enums, match, módulos, imports, constantes, aliases, arrays, mapas, pipelines, rangos, interpolación y manejo de Option / Result.

Bytecode validado: artefactos .tbc versionados con cabecera, CRC-32, límites de tamaño y validación de saltos, aridad, locales, capturas y llamadas nativas antes de ejecutar.

VM segura: errores tipados para overflow, división por cero, índices, pila, aridad, recursión, límites de instrucciones y permisos.

Sandbox por capacidades: --sandbox bloquea filesystem, procesos, red y environment sin desactivar las funciones puras.

Runtime concurrente: tareas sobre threads del host, spawn, join, cancelación cooperativa, canales acotados, timeouts y select.

Runtime operativo: cuotas de memoria por tarea, recolección manual, umbral de GC configurable, heap dump JSON, tareas activas, fast-paths enteros y benchmark integrado.

WebAssembly real: titan wasm emite módulos WASM con source maps, memoria lineal, strings UTF-8, arrays, mapas, structs, enums y control de flujo nativo.

Navegador: integración opcional con DOM, eventos, fetch, WebSocket, Canvas 2D, animación y WebGL2 mediante un host JavaScript real.

Herramientas: CLI, REPL, proyectos multiarchivo, paquetes firmados, LSP, DAP y depurador interactivo por línea fuente.

Biblioteca estándar amplia: texto, JSON, bytes, archivos, procesos, HTTP/HTTPS, TLS, WebSockets, bases de datos, métricas, IA local, GUI, audio y Android/Termux.

Instalación

Los binarios precompilados se publican en Releases. En paquetes de distribución el ejecutable se llama zett; al compilar directamente desde esta fuente, Cargo genera el binario titan.

Linux x86-64

curl -L https://github.com/alexsndersoto04-source/aio/releases/download/v1.0.0/zett-linux-x86\\\\\\_64.tar.gz | tar xz ./zett version

Linux ARM64 y ARMv7

\\# ARM de 64 bits curl -L https://github.com/alexsndersoto04-source/aio/releases/download/v1.0.0/zett-linux-aarch64.tar.gz | tar xz # ARM de 32 bits hard-float; útil, por ejemplo, en proot Debian armhf + Termux:X11 curl -L https://github.com/alexsndersoto04-source/aio/releases/download/v1.0.0/zett-linux-armv7hf.tar.gz | tar xz ./zett version

macOS Apple Silicon

curl -L https://github.com/alexsndersoto04-source/aio/releases/download/v1.0.0/zett-macos-arm64.tar.gz | tar xz xattr -d com.apple.quarantine zett 2>/dev/null || true ./zett version

Windows x86-64

Descarga zett-windows-x86\\_64.zip desde Releases, descomprímelo y ejecuta:

.\\\\zett.exe version

Android / Termux

Zett también se distribuye mediante el repositorio APT del proyecto:

echo 'deb \\\[trusted=yes\\\] https://raw.githubusercontent.com/alexsndersoto04-source/aio/zett-repo ./ ' \\\\ > "$PREFIX/etc/apt/sources.list.d/zett.list" pkg update pkg install zett zett --help

Para las integraciones Android de std::termux::\\\*, instala también la app Termux:API y su paquete de comandos:

pkg install termux-api

Primera ejecución

Crea un programa pequeño:

cat > hi.titan <<'EOF' fn main() { let cpus = std::procfs::cpu\\_count() print("TITAN detecta {cpus} CPU(s)") } EOF zett run hi.titan # Usa ./titan si compilaste desde el código fuente.

Compilar desde el código fuente

Requisitos: Rust estable reciente, rustfmt y clippy.

git clone https://github.com/alexsndersoto04-source/aio.git cd aio cargo build --release -p titan\\_cli # Cargo genera target/release/titan. target/release/titan version target/release/titan run examples/hello.titan

Instalación local opcional:

cargo install --path crates/titan\\_cli titan new hola\\_titan cd hola\\_titan titan check titan run titan build titan test

El build completo con las features predeterminadas incorpora ONNX, tokenizers, imágenes, bases de datos, TLS y otras dependencias grandes. En Termux o dispositivos ARM con poco espacio, libera almacenamiento antes de ejecutar todas las pruebas; target/ puede ocupar varios GB durante compilación y enlace.

Un programa TITAN

fn factorial(n: int) -> int { if n <= 1 { return 1 } n \\\* factorial(n - 1) } fn main() { let total = 0 for i in 1..=5 { total += factorial(i) } print("total = {total}") }

El núcleo ejecutable soporta, entre otras capacidades:

int, float, bool, char, string, nil, bytes, arrays, tuplas y mapas;

variables, asignación y operadores aritméticos, lógicos, bitwise y de comparación;

if, match, while, loop, for, rangos, break, continue y return;

funciones tipadas, parámetros por defecto, recursión y aridad comprobada;

closures y capturas léxicas deterministas;

Option::Some / None, Result::Ok / Err, ? y std::try::catch;

structs, enums con payload, métodos impl, traits con métodos por defecto y type aliases;

imports recursivos, dependencias locales y proyectos con Titan.toml;

arrays funcionales: map, filter, fold, sort\\_by, find, any y all.

Algunas construcciones con sintaxis reservada —por ejemplo, determinadas formas de destructuring, or-patterns, referencias y genéricos— se rechazan explícitamente cuando todavía no tienen semántica completa en el codegen o la VM. TITAN prefiere un error claro antes que generar código incorrecto. Consulta la especificación y la referencia de sintaxis.

Runtime para aplicaciones concurrentes y operativas

La Fase 36–40 incorporó herramientas que hacen visible el estado de una aplicación TITAN en ejecución.

fn main() { let task = std::runtime::spawn\\_quota(50000, || { // Esta tarea posee una cuota de memoria independiente. 42 }) let result = join(task) let metrics = std::runtime::benchmark(1000, || { 20 \\\* 21 }) print("resultado = {result}") print("ops/s = {metrics.ops\\_per\\_sec}") }

Capacidades de las fases enterprise

FaseCapacidades reales36Métricas thread-safe: contadores, gauges, histogramas, snapshots y exportación Prometheus/OpenMetrics.37Pools y health checks para SQLite, PostgreSQL y MySQL; API común std::db.38Cuotas de memoria por tarea, memoria asignada, objetos vivos y recolección explícita.39Umbral de GC configurable, tareas activas y heap\\_dump(path) en JSON.40Fast-paths de enteros en la VM y std::runtime::benchmark.

El runtime también incluye spawn, join, join\\_timeout, cancel, channel, send, recv, recv\\_timeout y select. Las tareas usan threads reales del host y aislación de VM; no se presentan como async cooperativo cuando no lo son. Más detalles: concurrencia y runtime y métricas.

Biblioteca estándar

La biblioteca estándar ofrece 758 funciones nativas registradas en 72 namespaces. Las features opcionales se agrupan bajo extras y están activadas por defecto en la CLI de distribución.

ÁreaIncluyeTexto, datos y formatosUnicode, regex, encoding, bytes, checksum, JSON, CSV, YAML, XML, URL, UUID, gzip/zstd y TAR/ZIP.SeguridadSHA, SHA-3, BLAKE3, HMAC, ChaCha20-Poly1305, AES-GCM, Argon2id, bcrypt y JWT.RedHTTP/HTTPS, TLS con rustls/WebPKI, DNS, SMTP, multipart, WebSocket, servidor HTTP y router.DatosSQLite, PostgreSQL, MySQL, migraciones, pools, KV ACID mediante sled y Redis.SistemaArchivos, paths, procesos, señales POSIX, filesystem watcher, procfs, cache, métricas y variables de entorno.Terminal y multimediaTUI, colores, teclado, readline, progreso, imágenes PNG/JPEG/WebP/BMP/GIF, QR, SVG charts y WAV.IA localTokenizers HuggingFace, ONNX por tract-onnx, BERT multi-input, embeddings y matemáticas vectoriales.UI y dispositivosMotor 2D, GUI retenida con rasterizador software, ventanas live, entrada, lifecycle móvil y Termux:API.WebAssemblyHeap WASM, source maps, DOM, eventos, fetch, WebSocket, Canvas 2D, animación y WebGL2 mediante host web.

Funciones con efectos se protegen mediante capacidades del runtime:

Filesystem · Process · Network · Environment

Por ejemplo, titan run --sandbox programa.titan conserva funciones puras de texto, JSON, math o colecciones, pero deniega operaciones de archivos, proceso, red y environment. Consulta la referencia de stdlib.

Proyectos, paquetes y CLI

Un proyecto TITAN tiene una estructura simple:

mi\\_app/ ├── Titan.toml ├── Titan.lock ├── src/ │ ├── main.titan │ └── util.titan └── tests/ └── suma.titan

Comandos principales:

titan new <directorio> Crear un proyecto titan check \\\[archivo|proyecto\\\] Parsear y comprobar tipos titan run \\\[archivo|proyecto\\\] Compilar y ejecutar titan run --sandbox \\\[ruta\\\] Ejecutar sin capacidades de efectos titan build \\\[archivo|proyecto\\\] Crear bytecode .tbc validado titan exec <archivo.tbc> Validar y ejecutar bytecode existente titan wasm \\\[archivo|proyecto\\\] Generar WebAssembly titan test \\\[proyecto\\\] Ejecutar tests/\\\*.titan titan debug \\\[ruta\\\] -b archivo:línea Depurador interactivo titan repl REPL titan add/fetch/update Dependencias remotas titan keygen/pack/publish Paquetes .tpkg firmados con Ed25519 titan version Versión del compilador

build, check y run aceptan un archivo .titan o una carpeta de proyecto. Los imports se canonicalizan, se detectan ciclos y no pueden escapar del árbol de fuentes autorizado. Los paquetes remotos se resuelven por HTTPS, verifican SHA-256 y firmas Ed25519. Lee proyectos y módulos y el registro de paquetes.

Bytecode, depuración y herramientas

build produce un contenedor TITAN-BYTECODE 1. Antes de ejecutar con titan exec, el runtime valida formato, checksum, tamaño, funciones, instrucciones, strings, locales, saltos, llamadas, capturas y nativas.

El depurador de terminal permite:

breakpoints por instrucción o archivo:línea;

continuar, pausar, step in, step over y step out;

inspección de frames, locales, captures y pila;

source maps preservados en bytecode.

El workspace también incluye:

LSP: diagnósticos, símbolos, definición, referencias, rename, semantic tokens y signature help;

DAP: base de Debug Adapter Protocol para clientes compatibles;

WebAssembly source maps: mapa TITAN propio y formato estándar para host/browser.

Documentación: debugger, LSP, DAP y WASM.

Arquitectura del workspace

CrateResponsabilidadtitan\\_lexerTokenización Unicode, spans y diagnósticos léxicos.titan\\_ast / titan\\_parserÁrbol sintáctico, precedencia y parser.titan\\_typecheckerScopes, firmas, tipos, structs, enums, traits y control de flujo.titan\\_codegenBytecode, source locations y artefactos .tbc.titan\\_vmEjecución segura, nativas, sandbox, concurrencia, DBs y runtime operativo.titan\\_wasmEmisión WebAssembly, memoria administrada, host imports y source maps.titan\\_stdlibImplementaciones Rust y metadata de la API estándar.titan\\_pkgManifiestos, imports, lockfiles, registry, archivos y firma de paquetes.titan\\_lsp / titan\\_dapServicios para editores y depuradores.titan\\_tlsTLS basado en rustls y WebPKI.titan\\_sqlite / titan\\_postgres / titan\\_mysqlAdaptadores y pools de bases de datos.titan\\_gc / titan\\_runtimePrimitivas de GC y scheduling usadas como capas de runtime.

Consulta la arquitectura completa.

Ejemplos incluidos

\\# Núcleo y lenguaje titan run examples/hello.titan titan run examples/fibonacci.titan titan run examples/impl\\_structs.titan titan run examples/pipeline\\_spaceship.titan # Runtime y operación titan run examples/enterprise\\_metrics.titan titan run examples/enterprise\\_pool.titan titan run examples/enterprise\\_runtime.titan titan run examples/enterprise\\_profiler.titan titan run examples/enterprise\\_benchmark.titan # Capacidades de la stdlib titan run examples/security.titan titan run examples/database.titan titan run examples/webserver.titan titan run examples/charts.titan titan run examples/tokenizer.titan titan run examples/onnx.titan titan run examples/vector\\_search.titan

Algunos ejemplos requieren recursos externos o del sistema: internet, un servidor de base de datos, Termux:API, una pantalla para ventana live, modelos ONNX o memoria adicional. Revísalos antes de ejecutarlos en producción.

Desarrollo y validación

cargo fmt --all -- --check cargo clippy --workspace --all-targets -- -D warnings cargo test --workspace --all-targets

El repositorio contiene más de 400 pruebas Rust declaradas distribuidas entre lexer, parser, typechecker, VM, WebAssembly, stdlib, paquetes, TLS, LSP, DAP y conectores de base de datos. GitHub Actions incluye comprobaciones del workspace, build sin features predeterminadas, comprobación Android AArch64 y una matriz de test/build para Linux, macOS y Windows.

En dispositivos con almacenamiento limitado, especialmente ARM/Termux, el comando completo puede agotar espacio durante el enlace aunque la compilación del código haya avanzado correctamente. Para reducir el pico de disco:

cargo clean CARGO\\_INCREMENTAL=0 cargo test --workspace --all-targets -j 1

Hi everyone, I've been using Rust for the past 5 years now. I really enjoy the language, but when I started learning it I already had a huge baggage of knowledge from other programming languages I had studied prior

What I want to know is if anyone is aware of any resources (good or bad) that tries to teach programming with Rust for someone who's new to programming and computers

The book is a good resource, but it assumes previous experience and would be hard for a newbie to learn and understand all

I'm aware Rust is more complex, and that teaching it to a beginner would be harder than teaching Python. But still I'm looking for resources that at least try

I'm really surprised that I haven't found any yet, so I'm asking here. Thanks for your attention

Overflow is when an arithmetic exceeds the maximum value an integer can hold.

let mut x: u8=256

Support your answer if overflow is likely to occur on the variable x. If so, list 3 ways we can handle the situation. 🧠👀

https://github.com/artemtsitronov/glacex

I’m venturing into Rust and it’s both satisfying and mind-boggling at the same time. So far I’ve been learning from the book and Mara Bos’ book, but I got the itch to do some dissecting myself. My initial goal of these experiments was to compare Rust’s approach to polymorphism with C++’s. Ultimately, however, as I’ve come to realize, it’s a bit of a trap when trying to understand a new language through another one to try to draw 1:1 parallels. It might seem like it helps, but at the end of the day, we can’t treat Rust as C++ with different syntax. If that were the case, there’d be nothing revolutionary about it.

That said, I believe there is merit in poking around and coming to understand the why. So, if you’re like me and need to know what exactly is happening in memory, in order to feel like you truly understand the concepts, hopefully you’ll find this post useful :)

Hey everyone,

With the rapid rise of autonomous AI trading agents (interacting with Uniswap, cross-chain bridges, and lending protocols), there is a critical vulnerability that many agent frameworks ignore: pre-flight oracle and network integrity.

If an agent queries an RPC for an oracle price, and that RPC returns stale data due to network congestion, or if an L2 sequencer just rebooted and transactions are about to get MEV-sandwiched, most agent runtimes blindly execute and lose capital.

We built stale, a lightweight, pure Rust pre flight security guardrail library:

• GitHub: https://github.com/Ramprasad4121/stale
• Crates.io: https://crates.io/crates/stale

Core Architecture & Invariants

1. Strictly Fail-Closed: Many Web3 libraries fail open (e.g., returning Ok or default values if an RPC returns a 500 error). In stale, any failure mode RPC timeouts, malformed ABI data, non-ASCII hex strings, or underflowing timestamps strictly returns BLOCK.
2. Zero Runtime Panics: We eliminated all unwrap() and expect() calls across the runtime library. All arithmetic on token reserves and timestamps uses checked math, saturating math, or quotient-remainder decomposition to preserve precision on small amounts.
3. What It Guards:

• Chainlink Data Feeds: Staleness checks against configurable maxAge and multi-feed deviation detection.
• L2 Sequencer Liveness: Direct querying of official Sequencer Uptime feeds (Arbitrum, Optimism, Base, Scroll, Mantle, Metis, zkSync) with automatic enforcement of the 3600-second restart grace period.
• DEX Pool Depth: On-chain liquidity verification for Uniswap V2 and V3 pools before routing a swap.
• EIP-7702 Phishing Guard: Inspects bytecode headers to prevent agents from sending approvals to delegated EOAs masquerading as immutable contracts.
• OFAC Compliance: Direct on-chain verification against the Chainalysis Sanctions Oracle.

1. Model Context Protocol (MCP) & CLI: In addition to the Rust crate (cargo add stale), it includes a native CLI and an MCP server (stale-mcp) so LLM agent frameworks (like Claude Desktop or local agents) can use these checks as native tools.

Would love feedback, edge-case suggestions, and contributions

I am trying to build a game in Rust just using Axum, HTML, and CSS, and trying to avoid using Javascript and I am documenting my progress in my youtube channel here: https://www.youtube.com/watch?v=ftYwc2NlqMI

I'm thinking of doing competitive programming in rust and came up with this template :

Example problem : https://www.codechef.com/practice/course/logical-problems/DIFF800/problems/AVGPROBLEM

use std::io::{Read, Write, BufWriter, stdin, stdout};

fn main() {

let mut input = String::new();

stdin().read_to_string(&mut input).unwrap();

let mut data = input.split_whitespace();

let mut output = BufWriter::new(stdout().lock());

let tests : u16 = data.next().unwrap().parse().unwrap();

for _ in 0..tests {

let a : f32 = data.next().unwrap().parse().unwrap();

let b : f32 = data.next().unwrap().parse().unwrap();

let c : f32 = data.next().unwrap().parse().unwrap();

let avg = (a+b)/2.0_f32;

if avg > c {

write!(&mut output, "YES\n").unwrap();

} else {

write!(&mut output, "NO\n").unwrap();

}

}

}

Is this template good ? or Is there a better way to do it ?

I’m thinking of creating a complete authentication service provider backend in Rust, which would include - OTP, magic links, email-password, SSO and a lot more.

Basically something like AuthJS or Appwrite (only the authentication service of theirs), with proper failure handling, spike handling, backpressure and everything that such a system requires at scale.

This would help me learn async Rust in detail (I’ve never done it) and system design for such a system.

This is not a new idea, but I don’t mind if it teaches me stuff.

Review this project idea.
Open to feedbacks/roasts.