Show HN: Tiny – An interpeted dynamic langauge with inline Go native functions

A high-performance, concurrent bytecode virtual machine and language written in Go. Tiny combines the development speed of dynamic coding with a robust, multi-threaded runtime engine. Tiny is a concurrent programming language and runtime system. It compiles source files into compact, stack-based bytecode instructions (.tbc) which run on a highly optimized virtual machine using slot-based local storage. The runtime engine features a multi-tiered execution model: an efficient interpreter for general logic and a Just-In-Time (JIT) compiler for performance-critical code. Key features include direct OS-level parallel threading, host-mirrored packed arrays, a chainable schema validation library, native WebAssembly extensions, and a built-in Language Server (LSP). Read the full documentation at tiny-lang-docs.github.io, or check out the examples to see Tiny in action. Precompiled binaries are available on the release page: For compilation from source instructions, see the online documentation. Dynamic Typing with Optional Hints Tiny is dynamically typed by default. You can write untyped code for rapid prototyping, or apply optional static type hints to variables, parameters, and function returns. The type system supports unions and generics. import std "io"; // Untyped variable let data = "untyped string"; // Explicitly typed variable const port: number = 8080; // Typed function parameters and return type fn calculatePayout(base: number, multiplier: number): number { return base * multiplier; } io.println(calculatePayout(100, 1.5)); Structural Interfaces and Shape Validation Tiny uses structural typing (shape-based validation). Objects are validated against interfaces at runtime based on their properties and methods. The JIT engine optimizes these checks by tracking object shapes and utilizing linear memory field offsets. import std "io"; interface Task { title: string done: bool } fn printTask(t: Task) { let status = t.done ? "Completed" : "Pending"; io.println(`${t.title} - Status: ${status}`); } // Valid structural matches printTask({ title: "Write Compiler Tests", done: true }); printTask({ title: "Optimize VM Dispatcher", done: false, priority: 1 }); Destructuring Assignment Tiny supports object and array destructuring for both let and const declarations. This includes support for nested patterns, default values, and property renaming. import std "io"; const user = { name: "Alice", age: 30, address: { city: "NYC", zip: "10001" } }; // Object destructuring with renaming and nesting let { name, address: { city } } = user; io.println(`${name} lives in ${city}`); // Array destructuring let coordinates = [10.5, 20.8, 30.0]; let [x, y] = coordinates; io.println(`X: ${x}, Y: ${y}`); Class Composition and Embedding Tiny emphasizes composition over deep inheritance. The embed keyword allows a class to delegate behavior to another class instance. If a method or field is missing on the parent, it is automatically resolved from the embedded instance. import std "io"; import std "json"; class Logger { field messages = [] fn log(message: string) { this.messages.push(message); io.println(`Log: ${message}`); } fn dump() { return this.messages; } } class SessionManager { field active = true embed logger fn init() { this.active = true; this.logger = Logger(); // Call to embedded class method this.log("Session manager initialized"); } fn close() { this.active = false; this.log("Session closed"); } } let session = SessionManager(); session.close(); // Directly calls the embedded Logger.dump method io.println(json.pretty(session.dump())); Pattern Matching The match block provides branch dispatching with support for literal values, variables, enums, union patterns, and guards. It is the primary way to extract data from enum variants. import std "io"; enum Result { Ok(value: any), Error(message: string) } fn process(res: Result) { match res { Result.Ok(val) if val > 0 { io.println(`Success: ${val}`); } Result.Ok(val) { io.println("Success with zero or negative value"); } Result.Error(msg) { io.println(`Error: ${msg}`); } _ { io.println("Unknown state"); } } } process(Result.Ok(42)); Scoped Cleanups with Defer The defer statement schedules a function call to execute immediately before the current surrounding function scope exits, regardless of early returns or thrown errors. import std "fs"; import std "io"; fn processFile(path: string) { io.println("Opening file stream..."); let file = fs.open(path); defer fn() { io.println("Running defer block: closing file stream."); file.close(); } io.println("Processing file data..."); } processFile("README.md"); Concurrency Model Parallel Thread Execution Tiny executes parallel operations using OS-level multi-threading. The spawn keyword starts a new execution routine on an isolated VM state space. Unlike event-loop models, Tiny runs tasks concurrently across all available CPU cores. import std "io"; import std "time"; let worker = spawn () fn() { time.sleep(1000); return "Worker

Show HN: Tiny – An interpeted dynamic langauge with inline Go native functions

Key takeaways

More in computer-science