Capture the screen in Go?

Is there is a cross-platform way to capture the screen in Google's Go? Or any way for that matter, but cross platform would be preferred.

Now there is:

https://github.com/vova616/screenshot

go get github.com/vova616/screenshot

Example:

package main

import "github.com/vova616/screenshot"

func main() {
    img, err := screenshot.CaptureScreen() // *image.RGBA
    myImg := image.Image(img) // can cast to image.Image, but not necessary
}

If you need macOS support as well (until the pull request is merged), get:

https://github.com/kesarion/screenshot

Unfortunately, there is no library to do this. There are a couple of bindings for magickwand (C programming language and the ImageMagick image processing libraries), see http://go-lang.cat-v.org/library-bindings but these are incomplete and do not have the screen capture feature.

Meanwhile as GeertJohan suggested, you can use os.exec to run an external program and capture the screen (see sample code below). For example, you can use import command from imagemagick to capture screen (should work on a platform that can run imagemagick)

package main

import (
	"bytes"
	"fmt"
	"log"
	"os/exec"
)

func main() {

	var buf bytes.Buffer

	path, err := exec.LookPath("import")
	if err != nil {
		log.Fatal("import not installed !")
	}
	fmt.Printf("import is available at %s\n", path)

	cmd := exec.Command("import", "-window", "root", "root.png")

	cmd.Stdout = &buf
	cmd.Stderr = &buf

	err = cmd.Run()
	if err != nil {
		panic(err)
	}
	fmt.Println(buf.String())
}

I don't know of any cross-platform library, but you can do this with the xgbutil library when an X server is present. You can see an example of how to capture a screenshot here.

If you wanted to get this working on Mac/Windows systems, I'd probably start by examining the source for go.wde, which includes backends for Windows and Mac. I doubt you'll directly find code to capture a screenshot in there, but it might give you some hints or a path to follow.

There is no cross-platform way to capture the screen in Google's Go, because capturing screen relies on a specific API of underlying operating systems. But there are libraries for Go that do this.

For example https://github.com/vova616/screenshot

This library seems to meet your needs:
https://godoc.org/github.com/kbinani/screenshot

> captures screen-shot image as image.RGBA. Mac, Windows, Linux, FreeBSD, OpenBSD, NetBSD, and Solaris are supported.

func Capture(x, y, width, height int) (*image.RGBA, error)
func CaptureDisplay(displayIndex int) (*image.RGBA, error)
func CaptureRect(rect image.Rectangle) (*image.RGBA, error)
func GetDisplayBounds(displayIndex int) image.Rectangle
func NumActiveDisplays() int

I cannot find a library to do this. Stable cross-platform screen-capturing requires a lot of work. Screen capturing requires interfacing with the operating systems' display manager/server or frame-buffer, which is different for a lot of operating systems and Linux distributions. You would have to write interfaces for each OS API (or wrap the libraries that provide the functionality), and then abstract all the different methods in a single package so it works cross-platform.

Another way to do this would be to run a existing screen capture application (command-line) to do the screen-capture work for you, including saving to a file. Then read the file in your go application. To make a Go application run a third-party application, use the os/exec package, it is in the standard library. For Linux you might use fbgrab to save the frame-buffer to a png file.

It is. It's a 2-step process:

Study https://github.com/ShareX/ShareX/tree/master/ShareX.ScreenCaptureLib to see which win32 API calls to make to capture the screen/window
Translate that logic to Go. You can use one of few existing win32 api Go bindings (e.g. https://github.com/AllenDang/w32). If they're missing needed functionality, you can add more wrappers.

For a native Windows solution, there is an example in C from the official Windows docs:

• https://learn.microsoft.com/en-gb/windows/win32/gdi/capturing-an-image

Now, from this example, this is the code using Windigo library:

package main

import (
    "runtime"
    "unsafe"

    "github.com/rodrigocfd/windigo/win"
    "github.com/rodrigocfd/windigo/win/co"
)

func main() {
    runtime.LockOSThread()

    cxScreen := win.GetSystemMetrics(co.SM_CXSCREEN)
    cyScreen := win.GetSystemMetrics(co.SM_CYSCREEN)

    hdcScreen := win.HWND(0).GetDC()
    defer win.HWND(0).ReleaseDC(hdcScreen)

    hBmp := hdcScreen.CreateCompatibleBitmap(cxScreen, cyScreen)
    defer hBmp.DeleteObject()

    hdcMem := hdcScreen.CreateCompatibleDC()
    defer hdcMem.DeleteDC()

    hBmpOld := hdcMem.SelectObjectBitmap(hBmp)
    defer hdcMem.SelectObjectBitmap(hBmpOld)

    hdcMem.BitBlt(
        win.POINT{X: 0, Y: 0},
        win.SIZE{Cx: cxScreen, Cy: cyScreen},
        hdcScreen,
        win.POINT{X: 0, Y: 0},
        co.ROP_SRCCOPY,
    )

    bi := win.BITMAPINFO{
        BmiHeader: win.BITMAPINFOHEADER{
            BiWidth:       cxScreen,
            BiHeight:      cyScreen,
            BiPlanes:      1,
            BiBitCount:    32,
            BiCompression: co.BI_RGB,
        },
    }
    bi.BmiHeader.SetBiSize()

    bmpObj := win.BITMAP{}
    hBmp.GetObject(&bmpObj)
    bmpSize := bmpObj.CalcBitmapSize(bi.BmiHeader.BiBitCount)

    rawMem := win.GlobalAlloc(co.GMEM_FIXED|co.GMEM_ZEROINIT, bmpSize)
    defer rawMem.GlobalFree()

    bmpSlice := rawMem.GlobalLock(int(bmpSize))
    defer rawMem.GlobalUnlock()

    hdcScreen.GetDIBits(hBmp, 0, int(cyScreen), bmpSlice, &bi, co.DIB_RGB_COLORS)

    bfh := win.BITMAPFILEHEADER{}
    bfh.SetBfType()
    bfh.SetBfOffBits(uint32(unsafe.Sizeof(bfh) + unsafe.Sizeof(bi.BmiHeader)))
    bfh.SetBfSize(bfh.BfOffBits() + uint32(bmpSize))

    fo, _ := win.FileOpen("C:\\users\\rodrigo\\desktop\\a.bmp", co.FILE_OPEN_RW_OPEN_OR_CREATE)
    defer fo.Close()

    fo.Write(bfh.Serialize())
    fo.Write(bi.BmiHeader.Serialize())
    fo.Write(bmpSlice)

    println("Done")
}