代码拉取完成，页面将自动刷新
xgo.dev | Docs | XGo vs. Go | Tutorials | Playground | XGo REPL (iXGo) | Contributing & compiler design
XGo is the first AI-native programming language that integrates software engineering into a unified whole.
XGo := C * Go * Python * JavaScript + Scratch
Our vision is to enable everyone to become a builder of the world.
The XGo programming language is designed for engineering, STEM education, and data science.
For more details, see Quick Start.
Different from the function call style of most languages, XGo 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.xgo.dev/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 | XGo code | Note |
|---|---|---|
| package main import "fmt" func main() { fmt.Println("Hi") } |
import "fmt" fmt.Println("Hi") |
Program structure: XGo 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 |
| name := "Ken" fmt.Printf( "Hi %s\n", name) |
name := "Ken" echo "Hi ${name}" |
Goodbye printf, use ${expr} in string literals |
| a := []int{1, 2, 3} | a := [1, 2, 3] | List literals |
| a = append(a, 4) a = append(a, 5, 6, 7) |
a <- 4 a <- 5, 6, 7 |
Append values to a list |
| 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 } |
XGo Classfiles: We can express OOP with global variables and functions. |
For more details, see The XGo Mini Specification.
XGo can choose different Go compilers as its underlying support. Currently known supported Go compilers include:
Currently, XGo 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/XGo, providing limitless possibilities such as:
If you wish to use llgo, specify the -llgo flag when initializing a XGo module:
xgo 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 XGo and LLGo):
module YourModulePath
go 1.21 // llgo 1.0
require github.com/goplus/lib v0.2.0
Based on LLGo, XGo can import 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 XGo, representing a null-terminated C-style string.
To run this example, you can:
cd YourModulePath # set work directory to your module
xgo mod tidy # for generating go.sum file
xgo 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 XGo, representing a Python string.
Here are more examples of XGo calling C/C++ and Python libraries:
To find out more about LLGo/XGo's support for C/C++ and Python in detail, please refer to homepage of llgo.
One language can change the whole world.
XGo 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 (and class framework) is as important to XGo as interface is to Go.
In the design philosophy of XGo, we do not recommend DSL (Domain Specific Language). But SDF (Specific Domain Friendliness) is very important. The XGo philosophy about SDF is:
Don't define a language for specific domain.
Abstract domain knowledge for it.
XGo introduces classfile and class framework to abstract domain knowledge.
Sound a bit abstract? Let's see some XGo class frameworks.
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:
xgo mod init hello
xgo get github.com/goplus/yap@latest
xgo mod tidy
xgo 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 xgo 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 XGo 2D Game Engine for more details.
Yes, now you can write shell script in XGo. 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 xgo run ./example.gsh directly to run.
See gsh: XGo DevOps Tools for more details.
Note: Requires go1.19 or later
winget install goplus.gop
sudo bash -c ' echo "deb [trusted=yes] https://pkgs.xgo.dev/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.xgo.dev/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/xgo.git
cd gop
# On mac/linux run:
./all.bash
# On Windows run:
all.bat
The XGo project welcomes all contributors. We appreciate your help!
For more details, see Contributing & compiler design.
If you like or are using XGo to learn or start your projects, please give it a star. Thanks!
此处可能存在不合适展示的内容，页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容，可点击提交进行申诉，我们将尽快为您处理。
1. 开源生态
2. 协作、人、软件
3. 评估模型
马建仓 AI 助手