Concurrency that reads like your intent.
Actors, channels, and structured scopes are built into the language from the start.
Siyo 0.6.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.6.0 adds sum types, exhaustive pattern matching, checked function signatures, collection helpers, and shared mutable closure captures. 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.
Sum types, exhaustive pattern matching, closures, and checked function types in one compact syntax.
Recent releasesThree releases.
Three releases.
One sharper language.
From module reliability to checked sum types, Siyo moved forward quickly without giving up bytecode and interpreter parity.
Module boundaries matured.
Imported types, impl methods, arrays, lambdas, and Java signatures now preserve their identity across module boundaries.
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.
The languageReadable on Monday.
Readable on Monday.
Powerful on Friday.
Siyo keeps the syntax compact while giving you real tools for real systems. Model results with sum types, transform collections, coordinate work, or call Java when you need to.
Pattern matching
Sum types
Closures
Actors
Channels
Java interop
type Result = Ok(int) | Err(string)
fn describe(result: Result) -> string {
match result {
Ok(value) => "value: " + toString(value),
Err(message) => "error: " + message,
}
}
fn main() {
println(describe(Ok(42)))
} 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.