go-vgo/robotgo

Được TopGit lập chỉ mục từ metadata GitHub: go-vgo/robotgo có 10.9k sao, viết chủ yếu bằng Go. RobotGo, Go Native cross-platform RPA, GUI automation, Auto test and Computer use @vcaesar
Tóm tắt dựng từ metadata GitHub của chính dự án — chưa có bài review TopGit. Trang sẽ tự động cập nhật khi bài review đầy đủ được xuất bản.
TopGit viết bài đầy đủ cho repo có nhiều sao nhất và được yêu cầu nhiều nhất. Trang này là snapshot trong thời gian chờ — xem README gốc ở tab READ ME.
Snapshot
Cộng tác viên hàng đầu
Xem cộng tác viên hàng đầu
Robotgo
English | 简体中文 | 繁體中文 | 日本語 | 한국어 | Français | Deutsch | Español | Русский | Português
Golang Desktop Automation, auto test and AI Computer Use.
Control the mouse, keyboard, read the screen, process, Window Handle, image and bitmap and global event listener.
RobotGo supports Mac, Windows, and Linux; and robotgo supports arm64 and x86-amd64.
I build Codg now, Easy code and work AI agent system: auto, asynchronous, concurrency, efficiently and High accuracy
RobotGo-Pro get the JavaScript, Python, Lua and others version, tech supports, new features and newest robotgo version ("no open-source version now").
Contents
- Docs
- Donate
- Binding
- Requirements
- Cgo-free Builds
- Installation
- Update
- Examples
- Type Conversion and keys
- Cross-Compiling
- Authors
- Plans
- License
Docs
- GoDoc
- API Docs (Deprecated, no updated)
Donate
Donors and sponsors, or others, Contact: [email protected]
Binding
ADB, packaging android adb and ios wda, robotgo compatible API.
Requirements
Go 1.26+ (see go.mod) and one backend:
- Default (Cgo):
CGO_ENABLED=1, a C compiler and the platform libraries below. - Pure Go (tested): no C toolchain; see Cgo-free Builds.
Both need the feature-specific dependencies for the features you use.
Default Cgo setup
macOS
Go and the Xcode Command Line Tools (Clang):
brew install go
xcode-select --install
Permissions (Cgo and pure Go): in System Settings > Privacy & Security, grant the app or terminal Accessibility (input) and Screen Recording (capture).
Windows
winget install GoLang.Go
Plus one C toolchain. LLVM-MinGW:
winget install MartinStorsjo.LLVM-MinGW.UCRT
$env:CC = "clang"
Or MinGW-w64 (WinLibs):
winget install BrechtSanders.WinLibs.POSIX.UCRT
$env:CC = "gcc"
The toolchain's bin (e.g. C:\mingw64\bin) must be on PATH and match
GOARCH. Any other Cgo-compatible compiler, such as a manual
MinGW-w64 install, also works.
Bitmap ships libpng for MinGW-w64 only; with another toolchain, build libpng yourself.
Linux (X11)
Build: GCC, libc headers, X11/XTest headers. Runtime: an X server with XTEST
and DISPLAY set. For native Wayland, see Cgo-free Builds.
Ubuntu / Debian:
# Go (Snap if the distro package is too old)
sudo snap install go --classic
# or: sudo apt install golang
# Core (Cgo): compiler, libc, X11, XTest
sudo apt install gcc libc6-dev libx11-dev xorg-dev libxtst-dev
# Clipboard (X11)
sudo apt install xsel xclip
# Bitmap: libpng
sudo apt install libpng++-dev
# GoHook: XCB, XKB
sudo apt install xcb libxcb-xkb-dev x11-xkb-utils libx11-xcb-dev libxkbcommon-x11-dev libxkbcommon-dev
Fedora:
# Core (Cgo): compiler, libc, X11, XTest
sudo dnf install gcc glibc-devel libX11-devel libXtst-devel
# Clipboard (X11)
sudo dnf install xsel xclip
# Bitmap: libpng
sudo dnf install libpng-devel
# GoHook: XKB (Fedora < 34: xorg-x11-xkb-utils-devel instead of xkbcomp-devel)
sudo dnf install libxkbcommon-devel libxkbcommon-x11-devel xkbcomp-devel
Feature-specific dependencies
Needed on top of the core setup, only for the features you use:
-
Linux clipboard (Cgo and pure Go):
xcliporxselon X11;wl-clipboardon Wayland:sudo apt install wl-clipboard # Ubuntu / Debian sudo dnf install wl-clipboard # Fedora -
Bitmap: libpng headers.
-
GoHook: XCB/XKB headers on Linux.
Bitmap and GoHook are separate Cgo packages; a pure-Go RobotGo backend does not remove their C requirements.
Cgo-free Builds
Tested pure-Go backends build and cross-compile with CGO_ENABLED=0
(no GCC, MinGW, Xcode or X11 headers). Same import path and API; a build tag
selects the backend — CGO_ENABLED=0 alone selects nothing.
Target GOOS | Build tag | Package | Runtime requirements |
|---|---|---|---|
windows | win | win | Win32 only, no extra runtime |
darwin | mac | darwin | System frameworks and privacy permissions |
linux | x11 | x11 | X server with XTEST, DISPLAY set |
linux | wayland | wayland | wlroots compositor, see Wayland |
linux | libei | libei | RemoteDesktop portal (GNOME/KDE), see libei |
purego is a shortcut: mac on macOS, win on Windows, wayland on
Linux. Add x11 or libei to override on Linux (-tags "purego,x11").
Use one backend tag matching GOOS; combinations such as x11,libei fail
to compile (purego plus one Linux override is the only exception).
Build commands
# Current OS
CGO_ENABLED=0 go build -tags purego .
# Cross-compile
CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build -tags win .
CGO_ENABLED=0 GOOS=darwin GOARCH=arm64 go build -tags mac .
CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -tags x11 .
CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -tags wayland .
CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -tags libei .
PowerShell: $env:CGO_ENABLED = "0"; go build -tags purego .
Build the module root (.) or your own package, not ./...: examples/ and
some subpackages need Cgo-only APIs.
Limitations
The runtime requirements above still apply. Cgo-only APIs such as
CaptureScreen / FreeBitmap do not exist; use CaptureImg. Unsupported
operations return ErrNotSupported (or an empty result).
mac: window management (GetTitle,GetBounds,ActivePid,ActiveName,MinWindow,MaxWindow,CloseWindow) uses Accessibility and needs the Accessibility permission;MaxWindowtoggles native full screen andGetClientequalsGetBounds.wayland,libei: Wayland has no protocol for the global cursor position.Location()reads the real cursor from Hyprland (IPC socket) and KDE Plasma (KWin script over D-Bus) when that query succeeds;waylandalso needs every output to share one scale ratio (differently scaled or rotated outputs fall back). Otherwise, and elsewhere (GNOME, Sway, other wlroots compositors), it returns the last position injected by RobotGo, not the physical cursor. Clipboard needswl-clipboard.
Wayland
A wlroots compositor (Sway, Hyprland, Wayfire, ...) with WAYLAND_DISPLAY and
XDG_RUNTIME_DIR set, exposing:
| Feature | Protocol global |
|---|---|
| Mouse control | zwlr_virtual_pointer_manager_v1 |
| Keyboard control | zwp_virtual_keyboard_manager_v1 |
| Screen capture | zwlr_screencopy_manager_v1 |
| Window management | zwlr_foreign_toplevel_manager_v1 |
GNOME and KDE do not provide these protocols; use libei there.
libei (GNOME / KDE)
Input goes through the xdg-desktop-portal RemoteDesktop D-Bus interface:
needs a session bus, xdg-desktop-portal and a backend implementing it
(xdg-desktop-portal-gnome, -kde or -wlr). The first run shows a consent
dialog; the restore token is cached under $XDG_STATE_HOME/robotgo.
Absolute motion uses a linked ScreenCast stream (default); set
libei.LinkScreenCast = false for relative motion only. Screen capture and
window management report ErrNotSupported.
Installation
go get github.com/go-vgo/robotgo
import "github.com/go-vgo/robotgo"
png.h: No such file or directory with Bitmap: see its libpng requirements and
issues/47.
Update
go get -u github.com/go-vgo/robotgo
Note go1.10.x C file compilation cache problem, golang #24355.
go mod vendor problem, golang #26366.
Examples
Mouse
package main
import (
"errors"
"fmt"
"github.com/go-vgo/robotgo"
)
func main() {
robotgo.MouseSleep = 300
robotgo.Move(100, 100)
fmt.Println(robotgo.Location())
robotgo.Move(100, -200) // multi screen supported
robotgo.MoveSmooth(120, -150)
fmt.Println(robotgo.Location())
robotgo.ScrollDir(10, "up")
robotgo.ScrollDir(20, "right")
robotgo.Scroll(0, -10)
robotgo.Scroll(100, 0)
robotgo.MilliSleep(100)
robotgo.ScrollSmooth(-10, 6)
// robotgo.ScrollRelative(10, -100)
robotgo.Move(10, 20)
robotgo.MoveRelative(0, -10)
robotgo.DragSmooth(10, 10)
robotgo.Click("wheelRight")
robotgo.Click("left", true)
robotgo.MoveSmooth(100, 200, 1.0, 10.0)
robotgo.Toggle("left")
robotgo.Toggle("left", "up")
// Check the returned errors, invalid arguments return an error
if err := robotgo.ScrollDir(10, "forward"); err != nil {
fmt.Println("robotgo.ScrollDir error:", err)
}
// Backends differ: Cgo returns an error, pure Go does a single left click and returns nil
if err := robotgo.Click("left", "double"); err != nil {
fmt.Println("robotgo.Click error:", err)
}
// MoveSmoothRelative reports a failed smooth move as ErrSmoothMove
err := robotgo.MoveSmoothRelative(10, -10)
if errors.Is(err, robotgo.ErrSmoothMove) {
fmt.Println("smooth move failed:", err)
}
// Pure-Go backends return ErrNotSupported for unsupported operations
err = robotgo.Move(100, 200)
if errors.Is(err, robotgo.ErrNotSupported) {
fmt.Println("robotgo.Move is not supported by this backend")
}
}
Keyboard
package main
import (
"errors"
"fmt"
"github.com/go-vgo/robotgo"
)
func main() {
robotgo.Type("Hello World")
robotgo.Type("だんしゃり", 0, 1)
// robotgo.Type("テストする")
robotgo.Type("Hi, Seattle space needle, Golden gate bridge, One world trade center.")
robotgo.Type("Hi galaxy, hi stars, hi MT.Rainier, hi sea. こんにちは世界.")
robotgo.Sleep(1)
// ustr := uint32(robotgo.CharCodeAt("Test", 0))
// robotgo.UnicodeType(ustr)
robotgo.KeySleep = 100
robotgo.KeyTap("enter")
// robotgo.Type("en")
robotgo.KeyTap("i", "alt", "cmd")
arr := []string{"alt", "cmd"}
robotgo.KeyTap("i", arr)
robotgo.MilliSleep(100)
robotgo.KeyToggle("a")
robotgo.KeyToggle("a", "up")
robotgo.WriteAll("Test")
text, err := robotgo.ReadAll()
if err == nil {
fmt.Println(text)
}
// Unknown key names return an error instead of pressing a wrong key
if err := robotgo.KeyTap("notakey"); err != nil {
fmt.Println("robotgo.KeyTap error:", err)
}
// TypeStr returns the first typing error, Type only returns the count
if err := robotgo.TypeStr("Hello, 世界"); err != nil {
fmt.Println("robotgo.TypeStr error:", err)
}
// Hold a modifier, then always release it and check both errors
if err := robotgo.KeyDown("shift"); err == nil {
err = errors.Join(robotgo.KeyTap("a"), robotgo.KeyUp("shift"))
if err != nil {
fmt.Println("shift + a error:", err)
}
}
}
Screen
package main
import (
"fmt"
"strconv"
"github.com/go-vgo/robotgo"
"github.com/vcaesar/imgo"
)
func main() {
x, y := robotgo.Location()
fmt.Println("pos: ", x, y)
color := robotgo.GetPixelColor(100, 200)
fmt.Println("color---- ", color)
sx, sy := robotgo.GetScreenSize()
fmt.Println("get screen size: ", sx, sy)
bit := robotgo.CaptureScreen(10, 10, 30, 30)
defer robotgo.FreeBitmap(bit)
img := robotgo.ToImage(bit)
imgo.Save("test.png", img)
num := robotgo.DisplaysNum()
for i := 0; i < num; i++ {
robotgo.DisplayID = i
img1, _ := robotgo.CaptureImg()
path1 := "save_" + strconv.Itoa(i)
robotgo.Save(img1, path1+".png")
robotgo.SaveJpeg(img1, path1+".jpeg", 50)
img2, _ := robotgo.CaptureImg(10, 10, 20, 20)
robotgo.Save(img2, "test_"+strconv.Itoa(i)+".png")
x, y, w, h := robotgo.GetDisplayBounds(i)
img3, err := robotgo.CaptureImg(x, y, w, h)
fmt.Println("Capture error: ", err)
robotgo.Save(img3, path1+"_1.png")
}
}
Bitmap
package main
import (
"fmt"
"github.com/go-vgo/robotgo"
"github.com/vcaesar/bitmap"
)
func main() {
bit := robotgo.CaptureScreen(10, 20, 30, 40)
// use `defer robotgo.FreeBitmap(bit)` to free the bitmap
defer robotgo.FreeBitmap(bit)
fmt.Println("bitmap...", bit)
img := robotgo.ToImage(bit)
// robotgo.SavePng(img, "test_1.png")
robotgo.Save(img, "test_1.png")
bit2 := robotgo.ToCBitmap(robotgo.ImgToBitmap(img))
fx, fy := bitmap.Find(bit2)
fmt.Println("FindBitmap------ ", fx, fy)
robotgo.Move(fx, fy)
arr := bitmap.FindAll(bit2)
fmt.Println("Find all bitmap: ", arr)
fx, fy = bitmap.Find(bit)
fmt.Println("FindBitmap------ ", fx, fy)
bitmap.Save(bit, "test.png")
}
OpenCV
package main
import (
"fmt"
"math/rand"
"github.com/go-vgo/robotgo"
"github.com/vcaesar/gcv"
"github.com/vcaesar/bitmap"
)
func main() {
opencv()
}
func opencv() {
name := "test.png"
name1 := "test_001.png"
robotgo.SaveCapture(name1, 10, 10, 30, 30)
robotgo.SaveCapture(name)
fmt.Print("gcv find image: ")
fmt.Println(gcv.FindImgFile(name1, name))
fmt.Println(gcv.FindAllImgFile(name1, name))
bit := bitmap.Open(name1)
defer robotgo.FreeBitmap(bit)
fmt.Print("find bitmap: ")
fmt.Println(bitmap.Find(bit))
// bit0 := robotgo.CaptureScreen()
// img := robotgo.ToImage(bit0)
// bit1 := robotgo.CaptureScreen(10, 10, 30, 30)
// img1 := robotgo.ToImage(bit1)
// defer robotgo.FreeBitmapArr(bit0, bit1)
img, _ := robotgo.CaptureImg()
img1, _ := robotgo.CaptureImg(10, 10, 30, 30)
fmt.Print("gcv find image: ")
fmt.Println(gcv.FindImg(img1, img))
fmt.Println()
res := gcv.FindAllImg(img1, img)
fmt.Println(res[0].TopLeft.Y, res[0].Rects.TopLeft.X, res)
x, y := res[0].TopLeft.X, res[0].TopLeft.Y
robotgo.Move(x, y-rand.Intn(5))
robotgo.MilliSleep(100)
robotgo.Click()
res = gcv.FindAll(img1, img) // use find template and sift
fmt.Println("find all: ", res)
res1 := gcv.Find(img1, img)
fmt.Println("find: ", res1)
img2, _, _ := robotgo.DecodeImg("test_001.png")
x, y = gcv.FindX(img2, img)
fmt.Println(x, y)
}
Event
package main
import (
"fmt"
// "github.com/go-vgo/robotgo"
hook "github.com/robotn/gohook"
)
func main() {
add()
low()
event()
}
func add() {
fmt.Println("--- Please press ctrl + shift + q to stop hook ---")
hook.Register(hook.KeyDown, []string{"q", "ctrl", "shift"}, func(e hook.Event) {
fmt.Println("ctrl-shift-q")
hook.End()
})
fmt.Println("--- Please press w---")
hook.Register(hook.KeyDown, []string{"w"}, func(e hook.Event) {
fmt.Println("w")
})
s := hook.Start()
<-hook.Process(s)
}
func low() {
evChan := hook.Start()
defer hook.End()
for ev := range evChan {
fmt.Println("hook: ", ev)
}
}
func event() {
ok := hook.AddEvents("q", "ctrl", "shift")
if ok {
fmt.Println("add events...")
}
keve := hook.AddEvent("k")
if keve {
fmt.Println("you press... ", "k")
}
mleft := hook.AddEvent("mleft")
if mleft {
fmt.Println("you press... ", "mouse left button")
}
}
Window
package main
import (
"fmt"
"github.com/go-vgo/robotgo"
)
func main() {
fpid, err := robotgo.FindIds("Google")
if err == nil {
fmt.Println("pids... ", fpid)
if len(fpid) > 0 {
robotgo.Type("Hi galaxy!", fpid[0])
robotgo.KeyTap("a", fpid[0], "cmd")
robotgo.KeyToggle("a", fpid[0])
robotgo.KeyToggle("a", fpid[0], "up")
robotgo.ActivePid(fpid[0])
robotgo.Kill(fpid[0])
}
}
robotgo.ActiveName("chrome")
isExist, err := robotgo.PidExists(100)
if err == nil && isExist {
fmt.Println("pid exists is", isExist)
robotgo.Kill(100)
}
abool := robotgo.Alert("test", "robotgo")
if abool {
fmt.Println("ok@@@ ", "ok")
}
title := robotgo.GetTitle()
fmt.Println("title@@@ ", title)
}
Authors
- The author is Evans
- Maintainers
Plans
- Better multiscreen support
- Update Window Handle
Contributors
- See contributors page for full list of contributors.
- See Contribution Guidelines.
License
Robotgo is primarily distributed under the terms of "the Apache License (Version 2.0)", with portions covered by various BSD-like licenses.
See LICENSE-APACHE, LICENSE.
Repo liên quan
Awesome Go, maintained at avelino/awesome-go, groups Go frameworks, libraries, and software into topic categories including Actor Model, Artificial Intelligence, Audio and Music, Authentication and Authorization, Blockchain, Bot Building, and Build Automation. Every linked entry gets a short description instead of a bare URL. The repository carries an MIT license and takes new entries through pull requests reviewed against its own contribution guidelines, which makes it a common bookmark for day-to-day Go development.
golang/go is the open source repository behind The Go Programming Language, holding the compiler, runtime, and standard library source that Go's official binaries are built from. The README frames Go's purpose as building software that is simple, reliable, and efficient, credits the project to thousands of contributors, and notes that this GitHub repo mirrors the canonical Git repository at go.googlesource.com/go.
Caddy's README promises automatic HTTPS, clustering and scale. Four Hacker News users say what held up and what did not.
Moby has 72,361 stars, but first-hand accounts are scarce: old GitHub issues, new networking complaints and a 2017 Hacker News launch thread.
Trả lời nhanh
go-vgo/robotgo có bao nhiêu sao?
go-vgo/robotgo có 10.9k sao GitHub — tải lại trang để xem số mới nhất, hoặc xem trực tiếp github.com/go-vgo/robotgo. TopGit phản chiếu số sao của GitHub nhưng không cam kết đến từng phút.
go-vgo/robotgo có những chủ đề gì?
GitHub topics của go-vgo/robotgo: "ai", "auto-test", "automation", "c", "computer-use", "go", "golang", "hook", "image", "mouse", "opencv", "robot", "robotgo", "rpa", "window". TopGit xếp repo vào nhóm Backend.
go-vgo/robotgo còn đang phát triển không?
Commit gần nhất trên go-vgo/robotgo là 3 tháng trước (theo timestamp GitHub). Repo có 967 fork — một chỉ báo về mức độ quan tâm của cộng đồng.
go-vgo/robotgo là gì?
go-vgo/robotgo (go-vgo/robotgo) là dự án Go trên GitHub. Theo mô tả gốc: RobotGo, Go Native cross-platform RPA, GUI automation, Auto test and Computer use @vcaesar
go-vgo/robotgo so với các dự án Backend khác thế nào?
go-vgo/robotgo được TopGit xếp vào nhóm Backend, với 10.9k sao GitHub và viết bằng Go. Xem trang chủ đề Backend trên TopGit để so sánh với các dự án tương tự theo số sao và mức độ hoạt động.
go-vgo/robotgo viết bằng ngôn ngữ gì?
go-vgo/robotgo chủ yếu viết bằng Go. Trường "language" của GitHub dựa trên phần lớn byte ở nhánh mặc định.
Vì sao go-vgo/robotgo được xếp vào nhóm Backend?
TopGit xếp go-vgo/robotgo vào nhóm Backend dựa trên GitHub topics và mô tả của repo (gắn thẻ: "ai", "auto-test", "automation"). Việc phân loại dựa trên metadata thật của repo, không phải đoán theo cảm tính biên tập.
Đọc đầy đủ README ở tab phía trên.
Chưa chắc robotgo có hợp với bạn?
Để ChatGPT, Claude hoặc Perplexity tìm hiểu giúp — bấm bên dưới và xem AI nói gì về robotgo.