goplus.org | Docs | Go+ vs. Go | Tutorials | Playground | iGo+ Playground | Contributing & compiler design
Our vision is to enable everyone to become a builder of the digital world.
- Simple and easy to understand
- Smaller syntax set than Python in best practices
- Derived from Go and easy to build large projects from its good engineering foundation
The Go+ programming language is designed for engineering, STEM education, and data science.
- For engineering: working in the simplest language that can be mastered by children.
- For STEM education: studying an engineering language that can be used for work in the future.
- For data science: communicating with engineers in the same language.
For more details, see Quick Start.
- Approaching natural language expression and intuitive (see How Go+ simplifies Go's expressions).
- Smallest but Turing-complete syntax set in best practices (see Go+ Specification for STEM Education).
- Fully compatible with Go and can mix Go/Go+ code in the same package (see Go+ Full Specification and Go/Go+ Hybrid Programming).
- Integrating with the C ecosystem including Python and providing limitless possibilities based on LLGo (see Support for C/C++ and Python).
- Does not support DSL (Domain-Specific Languages), but supports SDF (Specific Domain Friendliness) (see Go+ Classfiles).
Different from the function call style of most languages, Go+ recommends command style code:
println "Hello world"
To emphasize our preference for command style, we introduce echo
as an alias for println
:
echo "Hello world"
For more discussion on coding style, see https://tutorial.goplus.org/hello-world.
Code style is just the first step. We have made many efforts to make the code more intuitive and closer to natural language expression. These include:
Go code | Go+ code | Note |
---|---|---|
package main import "fmt" func main() { fmt.Println("Hi") } |
import "fmt" fmt.Println("Hi") |
Program structure: Go+ allows omitting package main and func main |
fmt.Println("Hi") | echo("Hi") | More builtin functions: It simplifies the expression of the most common tasks |
fmt.Println("Hi") | echo "Hi" | Command-line style code: It reduces the number of parentheses in the code as much as possible, making it closer to natural language |
a := []int{1, 2, 3} | a := [1, 2, 3] | List literals |
a := map[string]int{ "Monday": 1, "Tuesday": 2, } |
a := { "Monday": 1, "Tuesday": 2, } |
Mapping literals |
OnStart(func() { ... }) |
onStart => { ... } |
Lambda expressions |
type Rect struct { Width float64 Height float64 } func (this *Rect) Area() float64 { return this.Width * this.Height } |
var ( Width float64 Height float64 ) func Area() float64 { return Width * Height } |
Go+ Classfiles: We can express OOP with global variables and functions. |
For more details, see Go+ Specification for STEM Education.
Go+ can choose different Go compilers as its underlying support. Currently known supported Go compilers include:
- go (The official Go compiler supported by Google)
- llgo (The Go compiler supported by the Go+ team)
- tinygo (A Go compiler for small places)
Currently, Go+ defaults to using go as its underlying support, but in the future, it will be llgo.
LLGo is a Go compiler based on LLVM in order to better integrate Go with the C ecosystem including Python. It aims to expand the boundaries of Go/Go+, providing limitless possibilities such as:
- Game development
- AI and data science
- WebAssembly
- Embedded development
- ...
If you wish to use llgo, specify the -llgo
flag when initializing a Go+ module:
gop mod init -llgo YourModulePath
This will generate a go.mod
file with the following contents (It may vary slightly depending on the versions of local Go+ and LLGo):
module YourModulePath
go 1.21 // llgo 1.0
require github.com/goplus/llgo v0.9.7
Based on LLGo, Go+ can support importing libraries written in C/C++ and Python.
Here is an example (see chello) of printing Hello world
using C's printf
:
import "c"
c.printf c"Hello world\n"
Here, c"Hello world\n"
is a syntax supported by Go+, representing a null-terminated C-style string.
To run this example, you can:
cd YourModulePath # set work directory to your module
gop mod tidy # for generating go.sum file
gop run .
And here is an example (see pyhello) of printing Hello world
using Python's print
:
import "py/std"
std.print py"Hello world"
Here, py"Hello world"
is a syntax supported by Go+, representing a Python string.
Here are more examples of Go+ calling C/C++ and Python libraries:
- pytensor: a simple demo using py/torch
- tetris: a tetris game based on c/raylib
- sqlitedemo: a demo using c/sqlite
To find out more about LLGo/Go+'s support for C/C++ and Python in detail, please refer to homepage of llgo.
One language can change the whole world.
Go+ is a "DSL" for all domains.
Rob Pike once said that if he could only introduce one feature to Go, he would choose interface
instead of goroutine
. classfile
is as important to Go+ as interface
is to Go.
In the design philosophy of Go+, we do not recommend DSL
(Domain Specific Language). But SDF
(Specific Domain Friendliness) is very important. The Go+ philosophy about SDF
is:
Don't define a language for specific domain.
Abstract domain knowledge for it.
Go+ introduces classfile
to abstract domain knowledge.
Sound a bit abstract? Let's see some Go+ classfiles.
- Unit Test: classfile: Unit Test
- DevOps: gsh: Go+ DevOps Tools
- Web Programming: yap: Yet Another HTTP Web Framework
- Web Programming: yaptest: HTTP Test Framework
- Web Programming: ydb: Database Framework
- STEM Education: spx: A Go+ 2D Game Engine
This classfile has the file suffix .yap
.
Create a file named get.yap with the following content:
html `<html><body>Hello, YAP!</body></html>`
Execute the following commands:
gop mod init hello
gop get github.com/goplus/yap@latest
gop mod tidy
gop run .
A simplest web program is running now. At this time, if you visit http://localhost:8080, you will get:
Hello, YAP!
YAP uses filenames to define routes. get.yap
's route is get "/"
(GET homepage), and get_p_#id.yap
's route is get "/p/:id"
(In fact, the filename can also be get_p_:id.yap
, but it is not recommended because :
is not allowed to exist in filenames under Windows).
Let's create a file named get_p_#id.yap with the following content:
json {
"id": ${id},
}
Execute gop run .
and visit http://localhost:8080/p/123, you will get:
{"id": "123"}
See yap: Yet Another HTTP Web Framework for more details.
Through this example you can learn how to implement dialogues between multiple actors.
Here are some codes in Kai.spx:
onStart => {
say "Where do you come from?", 2
broadcast "1"
}
onMsg "2", => {
say "What's the climate like in your country?", 3
broadcast "3"
}
We call onStart
and onMsg
to listen events. onStart
is called when the program is started. And onMsg
is called when someone calls broadcast
to broadcast a message.
When the program starts, Kai says Where do you come from?
, and then broadcasts the message 1
. Who will recieve this message? Let's see codes in Jaime.spx:
onMsg "1", => {
say "I come from England.", 2
broadcast "2"
}
Yes, Jaime recieves the message 1
and says I come from England.
. Then he broadcasts the message 2
. Kai recieves it and says What's the climate like in your country?
.
The following procedures are very similar. In this way you can implement dialogues between multiple actors.
See spx: A Go+ 2D Game Engine for more details.
Yes, now you can write shell script
in Go+. It supports all shell commands.
Let's create a file named example.gsh and write the following code:
mkdir "testgsh"
Don't need a go.mod
file, just enter gop run ./example.gsh
directly to run.
See gsh: Go+ DevOps Tools for more details.
Note: Requires go1.19 or later
winget install goplus.gop
sudo bash -c ' echo "deb [trusted=yes] https://pkgs.goplus.org/apt/ /" > /etc/apt/sources.list.d/goplus.list'
sudo apt update
sudo apt install gop
sudo bash -c 'echo -e "[goplus]\nname=Go+ Repo\nbaseurl=https://pkgs.goplus.org/yum/\nenabled=1\ngpgcheck=0" > /etc/yum.repos.d/goplus.repo'
sudo yum install gop
Install via brew
$ brew install goplus
git clone https://github.com/goplus/gop.git
cd gop
# On mac/linux run:
./all.bash
# On Windows run:
all.bat
- vscode: Go/Go+ for Visual Studio Code
The Go+ project welcomes all contributors. We appreciate your help!
For more details, see Contributing & compiler design.
If you like or are using Go+ to learn or start your projects, please give it a star. Thanks!