Concurrency that reads like your intent.
Actors, channels, and structured scopes are built into the language from the start.
Siyo 0.7.0 is out
Concurrency on the JVM.By Design.
Safe and simple by default. Siyo is a compiled language with actors, channels, and native Java interop. Familiar enough to start today. Different enough to enjoy it.
Bundled runtime · No Java installation required
actor Store { data: map } impl Store {fn new() -> Store {Store { data: map() }} fn set(self, key: string,value: string) -> string {self.data.set(key, value)"OK"}} mut store = spawn Store.new()println(store.set("lang", "siyo"))›siyoc run store.siyoOK
Direct bytecode
JJava 21+
In plain terms
What is the Siyo programming language?
Siyo is an experimental programming language that compiles directly to Java Virtual Machine bytecode. Its concurrency model combines actors, buffered and unbuffered channels, and structured scope blocks that join spawned work automatically. Siyo programs can also call Java constructors, methods, and libraries through native interoperability.
The compiler shares one frontend from lexing through lowering, then runs code through an ASM bytecode emitter or a tree-walking interpreter. Parity tests compare both execution paths. Siyo 0.7.0 adds generic containers, sum types and functions, checked interfaces, typed errors, explicit module exports, and import aliases. It targets Java 21 virtual threads and ships with project tooling, Maven dependency resolution, and a bundled runtime. The project is source available and experimental.
Why SiyoSmall language.
Small language.
Serious machinery.
Designed around the way software is built now: concurrent by default, connected to an enormous ecosystem, and pleasant to read six months later.
Bytecode, directly. No translation layer.
Siyo emits standard JVM bytecode and runs beside Java and Kotlin with access to the full ecosystem.
Modern ideas, without ceremony.
Generics, checked interfaces, typed errors, and exhaustive pattern matching in one compact syntax.
Recent releasesThree releases.
Three releases.
One sharper language.
From stronger module boundaries to generics and interfaces, each release keeps bytecode and interpreter behavior aligned.
Real programs hardened the compiler.
A 3,000-line HTTP library exposed 32 defects. Namespaced modules, located diagnostics, and a safer Java boundary followed.
Sum types arrived.
Exhaustive variant matching, checked function types, collection helpers, indexed maps, and shared mutable captures landed together.
Types cross new boundaries.
Generic containers and functions, checked interfaces, typed errors, explicit exports, and import aliases expand what programs can express.
The languageReadable on Monday.
Readable on Monday.
Powerful on Friday.
Siyo keeps the syntax compact while giving you real tools for real systems. Model data with generic sum types, accept interface implementations, catch typed errors, or coordinate work with actors and channels.
Pattern matching
Generic sum types
Interfaces
Typed errors
Module exports
Closures
Actors
Channels
Java interop
type Maybe<T> = Just(T) | Nothing
fn identity<T>(value: T) -> T { value }
fn describe(value: Maybe<int>) -> string {
match value {
Just(n) => "number: " + toString(n),
Nothing => "no number",
}
}
fn main() {
imut counts: Map<string, int> = {"visits": 7}
println(toString(identity(counts["visits"]) + 1))
println(describe(Just(42)))
}Also new in 0.7.0
- Reflection — inspect structs with
fields,field,setField,toMap, andtypeName. - Numeric widening — mix numeric types in arithmetic, parameters, and returns. Narrowing still needs an explicit conversion.
- Set literals — write
#{"red", "green"};lennow handles maps and sets too. - do / while — run the loop body once before testing its condition, with normal
breakandcontinue. - Method-style builtins — chain calls like
" hello ".trim().toUpper(). - Backend parity fixes — consistent struct printing, Java exception messages, and value-producing
tryexpressions; full module paths avoid JVM class-name collisions.
Module visibility is opt-in: a module that marks nothing exports everything. Its first pub switches it to explicit exports.
Still experimental: generic structs and interface bounds or default methods are not supported. Empty struct literals and map literals as a function body’s tail value remain limitations.
Read the 0.7.0 release notes Under the hoodOne frontend.
One frontend.
Two ways to run.
The compiler and interpreter share the same analysis pipeline, so compiled programs and debug runs keep identical semantics.
01LexerTokens
02ParserSyntax tree
03BinderTypes & names
04LowererControl flow
EmitterJVM bytecode
EvaluatorInterpreter
ASM backend emits standard .class files
Virtual threads power lightweight concurrency
Parity tests compare both execution paths
Start buildingFrom zero to running
From zero to running
in one command.
Install Siyo with its bundled runtime, then create your first project.
curl -fsSL siyolang.org/install | sh01
Windows and source installation siyoc new my-app02cd my-app03siyoc run One language, wide reach
Build past the demo.
Siyo already ships with the pieces to explore real applications.
Make something
unexpected.
Siyo is young, public, and ready for curious builders.