borgo-lang/borgo has 4,632 GitHub stars and 64 forks. GitHot measured 0 stars in 24 hours, 0 in 7 days, and 0 in 15 days. Last checked 2026-11-22 17:43 UTC. Last push 2024-10-27.
Progression mesurée des étoiles
- in 24h
- 0
- in 7 days
- 0
- in 15 days
- 0
- in 1 month
- Historique en cours
Variations nettes sur des périodes qui se chevauchent, pas des totaux quotidiens. Les mesures absentes restent vides. Les étoiles indiquent l’intérêt, pas la qualité.
À propos
Borgo est un langage à typage statique qui se compile en Go.
Outils de développementREADME.md
OriginalThe Borgo Programming Language

I want a language for writing applications that is more expressive than Go but less complex than Rust.
Go is simple and straightforward, but I often wish it offered more type safety. Rust is very nice to work with (at least for single threaded code) but it's too broad and complex, sometimes painfully so.
Borgo is a new language that transpiles to Go. It's fully compatible with existing Go packages.
Borgo syntax is similar to Rust, with optional semi-colons.
Tutorial
Check out the online playground for a tour of the language.
You can also take a look at test files for working Borgo code:
Features
Algebraic data types and pattern matching
use fmt
enum NetworkState {
Loading,
Failed(int),
Success(string),
}
let msg = match state {
NetworkState.Loading => "still loading",
NetworkState.Failed(code) => fmt.Sprintf("Got error code: %d", code),
NetworkState.Success(res) => res,
}
Option<T> instead of nil
// import packages from Go stdlib
use fmt
use os
let key = os.LookupEnv("HOME")
match key {
Some(s) => fmt.Println("home dir:", s),
None => fmt.Println("Not found in env"),
}
Result<T, E> instead of multiple return values
use fmt
use net.http
fn makeRequest() -> Result<int, error> {
let request = http.Get("http://example.com")
match request {
Ok(resp) => Ok(resp.StatusCode),
Err(err) => Err(fmt.Errorf("failed http request %w", err))
}
}
Error handling with ? operator
use fmt
use io
use os
fn copyFile(src: string, dst: string) -> Result<(), error> {
let stat = os.Stat(src)?
if !stat.Mode().IsRegular() {
return Err(fmt.Errorf("%s is not a regular file", src))
}
let source = os.Open(src)?
defer source.Close()
let destination = os.Create(dst)?
defer destination.Close()
// ignore number of bytes copied
let _ = io.Copy(destination, source)?
Ok(())
}
Guessing game example
Small game from the Rust book, implemented in Borgo.
Things to note:
- import packages from Go stdlib
strconv.Atoireturns anOption<int>Reader.ReadStringreturns aResult<string, error>(which can be unwrapped)
use bufio
use fmt
use math.rand
use os
use strconv
use strings
fn main() {
let reader = bufio.NewReader(os.Stdin)
let secret = rand.Intn(100) + 1
loop {
fmt.Println("Please input your guess.")
let text = reader.ReadString('\n').Unwrap()
let text = strings.TrimSpace(text)
let guess = match strconv.Atoi(text) {
Ok(n) => n,
Err(_) => continue,
}
fmt.Println("You guessed: ", guess)
if guess < secret {
fmt.Println("Too small!")
} else if guess > secret {
fmt.Println("Too big!")
} else {
fmt.Println("Correct!")
break
}
}
}
Running locally
Borgo is written in Rust, so you'll need cargo.
To compile all .brg files in the current folder:
$ cargo run -- build
The compiler will generate .go files, which you can run as normal:
# generate a go.mod file if needed
# $ go mod init foo
$ go run .
Explorer des projets similaires
Chargement…