Surab is an experimental programming language written in Rust and C#.
- Consistent syntax -> Easy to read, write, and learn
- One proper way to do something -> Decrease noise and mental overhead associated with choices
- Builtin syntax to support common patterns -> Less boilerplate
- Module system -> Better organization and more compilation trimming
- Functional patterns only where it makes sense -> Succinct language syntax to support useful functional features
- Mutability as intent, not type behavior -> Mutability is a first-class usage capability, not a property of types
This is an example that works right now but does not represent the final design of the language.
import math;
@public
alias Area as f32;
alias fn () Area as AreaGetter;
fn print_area(getter: AreaGetter) {
var area = getter();
print(area);
}
/// Marks a type that has an [Area].
@public
trait HasArea {
get_area() Area;
}
struct Square {
side: f32;
impl HasArea {
get_area() Area {
math::pow(this.side, 2)
}
}
}
@extern
fn call_into_c(num: f32);
fn main() {
var square = Square.{
side: 4.0,
};
print_area(square.get_area);
call_into_c(square.side);
}
Features marked as completed usually meet the completion criteria for an MVP version, not the final planned version. This list is not exhaustive.
- Full working pipeline: lexer, parser, analyzer, compiler, runner, language server
- C ABI and calling into Rust
- Local types and functions
- Type inference
- Module system
- Aliasing system
- Trait system
- Trait based restrictions
- Pattern matching
- Monadic system
- Unsafe pointers
- Bultins and intrinsics
- Generics
- Mutable intent
- Arrays, Slices, Enums, etc
- Classes?, boxing, and heap allocations
- Flow analysis
- First class immutability
- Runtime: GC
- Testing framework
- Builtin formatting
- Code generation support (committed generated inline snippets)
- LSP (vscode)
- Self-hosting: Eventual goal is to rewrite the compiler frontend in Surab and remove C#.
Surab is a compiled garbage collected language with functional features.
The full spec is not available in this repo right now as it's heavily subject to change.
Supported platforms to build from:
- Windows x86_64 - ✅
- Windows aarch64 - TBD
- Linux x86_64 - ✅
- Linux aarch64 - TBD
- macOS - TBD
Written in C#, this includes lexing, parsing, and analyzing Surab source code. This is meant to be used as a drop in library to analyze any Surab source code.
Written in C#, this includes lowering and compiling into IR using LLVM (scpp). This is meant to be used as a drop in library that can compile any Surab source code.
Written in C++, this is a native wrapper around the LLVM C++ library and is meant to be used by the compiler frontend to call into LLVM. Prebuilt bins of this native lib are provided to avoid the dependency on LLVM/Clang in the majority of cases. For more check DEVELOPMENT.md.
Written in C#, this is an easy way to run through the full pipeline, to script some quick Surab code.
Written in Surab, this contains the Surab libraries. Right now it includes a prelude module that is implicitly included in all Surab projects.
Written in Rust, this is the Surab runtime. Right now this only has some code to test the C ABI when Surab calls into Rust. Later it will include the GC and any other runtime requirement.
Written in C#, this is a fully working language server that currently supports vscode and is to be developed along with the compiler. Currently has a syntax tokenizer and various analysis features along with diagnostic reporting.
Written in C#, contains a generator script that produces parts of the compiler frontend using json files (e.g. AST classes).
Samples written in Surab.
There's no roadmap. I work on this when I feel like it and sometimes take long breaks. Give CONTRIBUTING.md and DEVELOPMENT.md a read if interested.