Package to create apps with GO, HTML and CSS. Supports: MacOS, Windows in progress

<h1 align="center">
    <a href="https://go-app.dev">
        <img alt="go-app"  width="150" height="150" src="docs/web/icon.png">
    </a>
</h1>

<p align="center">
	<a href="https://github.com/maxence-charriere/go-app/actions"><img src="https://github.com/maxence-charriere/go-app/actions/workflows/build.yml/badge.svg?branch=master" alt="GitHub actions"></a>
    <a href="https://goreportcard.com/report/github.com/maxence-charriere/go-app"><img src="https://goreportcard.com/badge/github.com/maxence-charriere/go-app" alt="Go Report Card"></a>
	<a href="https://GitHub.com/maxence-charriere/go-app/releases/"><img src="https://img.shields.io/github/release/maxence-charriere/go-app.svg" alt="GitHub release"></a>
	<a href="https://pkg.go.dev/github.com/maxence-charriere/go-app/v10/pkg/app"><img src="https://img.shields.io/badge/dev-reference-007d9c?logo=go&logoColor=white&style=flat" alt="pkg.go.dev docs"></a>
    <a href="https://twitter.com/jonhymaxoo"><img alt="Twitter URL" src="https://img.shields.io/badge/twitter-@jonhymaxoo-35A9F8?logo=twitter&style=flat"></a>
    <a href="https://opencollective.com/go-app" alt="Financial Contributors on Open Collective"><img src="https://opencollective.com/go-app/all/badge.svg?label=open+collective&color=4FB9F6" /></a>
</p>

Go-app is a package for **building progressive web apps (PWA)** with the [Go programming language (Golang)](https://golang.org) and [WebAssembly (Wasm)](https://webassembly.org).

Shaping a UI is done by using a **[declarative syntax](https://go-app.dev/declarative-syntax) that creates and compose HTML elements only by using the Go programing language**.

It **uses [Go HTTP standard](https://golang.org/pkg/net/http) model**.

An app created with go-app can out of the box **runs in its own window**, **supports offline mode**, and is **SEO friendly**.

## Documentation (built with go-app)

[![go-app documentation](docs/web/images/go-app.png)](https://go-app.dev)

## Install

**go-app** requirements:

- [Go 1.18](https://golang.org/doc/go1.17) or newer
- [Go module](https://github.com/golang/go/wiki/Modules)

```sh
go mod init
go get -u github.com/maxence-charriere/go-app/v10/pkg/app
```

## Declarative syntax

Go-app uses a [declarative syntax](https://go-app.dev/declarative-syntax) so you can **write reusable component-based UI elements** just by using the Go programming language.

Here is a Hello World component that takes an input and displays its value in its title:

```go
type hello struct {
	app.Compo

	name string
}

func (h *hello) Render() app.UI {
	return app.Div().Body(
		app.H1().Body(
			app.Text("Hello, "),
			app.If(h.name != "", func() app.UI {
				return app.Text(h.name)
			}).Else(func() app.UI {
				return app.Text("World!")
			}),
		),
		app.P().Body(
			app.Input().
				Type("text").
				Value(h.name).
				Placeholder("What is your name?").
				AutoFocus(true).
				OnChange(h.ValueTo(&h.name)),
		),
	)
}
```

## Standard HTTP

Apps created with go-app complies with [Go standard HTTP](https://golang.org/pkg/net/http) package interfaces.

```go
func main() {
	// Components routing:
	app.Route("/", func() app.Composer { return &hello{} })
	app.Route("/hello", func() app.Composer { return &hello{} })
	app.RunWhenOnBrowser()

	// HTTP routing:
	http.Handle("/", &app.Handler{
		Name:        "Hello",
		Description: "An Hello World! example",
	})

	if err := http.ListenAndServe(":8000", nil); err != nil {
		log.Fatal(err)
	}
}
```

## Getting started

**Read the [Getting Started](https://go-app.dev/getting-started) document**.

## Built with go-app

- [Lofimusic.app](https://lofimusic.app/collegemusic-lonely)
- [Murlok.io](https://murlok.io/)
- [liwasc](https://pojntfx.github.io/liwasc/)
- [go-app Docs](https://go-app.dev/)

## Contributors

### Code Contributors

This project exists thanks to all the people who contribute. [[Contribute](CONTRIBUTING.md)].

<a href="https://github.com/maxence-charriere/go-app/graphs/contributors"><img src="https://opencollective.com/go-app/contributors.svg?width=890&button=false" /></a>

### Financial Contributors

Become a financial contributor and help us sustain [go-app](https://github.com/maxence-charriere/go-app) development. [[Contribute](https://opencollective.com/go-app/contribute)]

#### Individuals

<a href="https://opencollective.com/go-app"><img src="https://opencollective.com/go-app/individuals.svg?width=890"></a>

#### Organizations

Support this project with your organization. Your logo will show up here with a link to your website. [[Contribute](https://opencollective.com/go-app/contribute)]

<a href="https://opencollective.com/go-app/organization/0/website"><img src="https://opencollective.com/go-app/organization/0/avatar.svg"></a>
<a href="https://opencollective.com/go-app/organization/1/website"><img src="https://opencollective.com/go-app/organization/1/avatar.svg"></a>
<a href="https://opencollective.com/go-app/organization/2/website"><img src="https://opencollective.com/go-app/organization/2/avatar.svg"></a>
<a href="https://opencollective.com/go-app/organization/3/website"><img src="https://opencollective.com/go-app/organization/3/avatar.svg"></a>
<a href="https://opencollective.com/go-app/organization/4/website"><img src="https://opencollective.com/go-app/organization/4/avatar.svg"></a>
<a href="https://opencollective.com/go-app/organization/5/website"><img src="https://opencollective.com/go-app/organization/5/avatar.svg"></a>
<a href="https://opencollective.com/go-app/organization/6/website"><img src="https://opencollective.com/go-app/organization/6/avatar.svg"></a>
<a href="https://opencollective.com/go-app/organization/7/website"><img src="https://opencollective.com/go-app/organization/7/avatar.svg"></a>
<a href="https://opencollective.com/go-app/organization/8/website"><img src="https://opencollective.com/go-app/organization/8/avatar.svg"></a>
<a href="https://opencollective.com/go-app/organization/9/website"><img src="https://opencollective.com/go-app/organization/9/avatar.svg"></a>


Auto generated Go wrapper for [Dear ImGui](https://github.com/ocornut/imgui) via [cimgui](https://github.com/cimgui/cimgui)

[![Go Report Card](https://goreportcard.com/badge/github.com/AllenDang/cimgui-go)](https://goreportcard.com/report/github.com/AllenDang/cimgui-go)
![Build Status](https://github.com/AllenDang/cimgui-go/actions/workflows/test.yaml/badge.svg)
![Linter Status](https://github.com/AllenDang/cimgui-go/actions/workflows/golangci-lint.yaml/badge.svg)
[![GoDoc](https://pkg.go.dev/badge/github.com/AllenDang/cimgui-go?utm_source=godoc)](https://pkg.go.dev/mod/github.com/AllenDang/cimgui-go)
[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go#gui)

# cimgui-go 

This project aims to generate go wrapper for Dear ImGui.

It comes with [several default backends](supported-backends) implemented.

It works on macOS(arm64/x86), windows(x64), Arch Linux (Gnome/KDE) and Fedora Workstation 36+, idealy other linux GUI should works as well. Check out [`examples`](./examples): cd in and `go run .`.

> [!note]
> It is a known issue that newer versions of cimgui-go does not compile on some older linux distributions (e.g. Debian).
> This is caused by shared libraries being compiled with GitHub Actions version of Ubuntu ([check out this table for the exact Ubunt version](https://docs.github.com/en/actions/how-tos/using-github-hosted-runners/using-github-hosted-runners/about-github-hosted-runners#standard-github-hosted-runners-for-public-repositories)) and not being compatible with older versions of glibc.
> Track [#157](https://github.com/AllenDang/cimgui-go/issues/157).

## Setup

There are several dependencies you might need to install on your linux machine.
Take a look [here](https://github.com/allendang/giu#install)

## Module overview

This module contains several packages that may need some explanation:

| Package | Description |
| ------- | ----------- |
| `imgui`, `implot`, `imnodes`, e.t.c. | Actual Dear ImGui (and plugins) bindings. Used to display widgets and other UI stuff. |
| `examples` | Just like the name suggests - a handful of examples that show how to use cimgui-go |
| `cmd/codegen` | Code generator that generates Go bindings. |
| `backend`  | Abstraction layer for various backends (glfw, sdl, ebiten, e.t.c.). |
| `backend/*` | Specific backends (implements `backend.Bckend`) utilizing system libraries to render ImGui. |
| `impl`     | Packages responsible for imgui <-> backend interactions. (Use them if you want to implement your own backend. Not needed if using one of `backend/*` implementations). |
| `cwrappers` | C wrappers for Dear ImGui and the team. Contains also source (C++) code. |
| `lib`     | Pre-compiled set of libraries that are used to link with cimgui-go. Contains static libraries for ImGui, GLFW, SDL2 and other dependencies. |
| `thirdparty` | 3rd party headers like GLFW and SDL2. Used by backend. |
| `utils`   | some utiliity functions that are used by cimgui-go. Also contains `Vector` implementation. |
| `templates` (not package) | Stores files used during generation. |

## Supported Backends

In order to make it easy in use, cimgui-go implemented a few imgui backends. All of them are placed in `backend/` sub-packages.
To see more details about usage of a specific backend, take a look at the [examples](./examples).

We support the following backends:
- [GLFW](./examples/glfw). (GLFW 3.3 + OpenGL)
- [SDL2](./examples/sdl). (SDL 2 + OpenGL)
- [Ebitengine](./examples/ebiten) (`import "github.com/AllenDang/cimgui-go/backend/ebitenbackend"`).
- [DRM/EGL](./examples/drm-egl) (`import "github.com/AllenDang/cimgui-go/backend/drmeglbackend"`, Linux only).

> [!important]
> Remember that various solution use different C libraries that can conflict with each other.
> It is recommended not to import e.g. GLFW and SDL backends at the same time as it may result in linker crash.

> [!note]
> The DRM/EGL backend is intended for embedded Linux / kiosk setups that render directly through DRM/KMS without X11 or Wayland. It currently focuses on rendering and texture upload; desktop-style window management, drag-and-drop, and input event wiring are not implemented yet.

> [!tip]
> To build the DRM/EGL example/backend, install `libdrm-dev`, `libgbm-dev`, `libegl1-mesa-dev`, `libgles2-mesa-dev`, then use `go run ./examples/drm-egl`.

> [!tip]
> Because [glfw v3.4](https://github.com/glfw/glfw) defaults to wayland when possible and wayland does not support some of imgui features, there is a `glfwbackend.ForceX11()`. Call it before creating a `glfwbackend.GLFWBakend` instance.

## Naming convention

- For functions, 'Im/ImGui/ig' is trimmed.
- `Get` prefix is also removed (with some exceptions).
- If function comes from `imgui_internal.h`, `Internal` prefix is added.

> [!note]
> You may notice some functions signatures that might make no sense (ex. `Text(fmt string)` vs `TextUnformatted(text string)`).
> This is because in the original code there are some "varargs" (`...`) arguments (`void Text(const char* fmt, ...)`).
> Unfortunately in the current state of CGO, there is no way to pass varargs to C functions, so these functions are generated without varargs. [See also](https://github.com/golang/go/issues/975).

## Pointers and Slices

Unfortunately, in C there is no way to distinguish between a pointer and a slice.
We had to bring this inconvenience to Go as well.
Our code defaults to pointers, but you can easily convert your slice to a pointer by simply `&(slice[0])`.

> [!tip]
> There are some utility functions in `utils` package including:
> - `utils.SliceToPtr(slice []T) *T` - converts a slice to a pointer.
> - `utils.PtrToSlice(ptr *T, size int) []T` - converts a pointer to a slice of given size. **Be careful with size! This may cause segmentation fault if used incorrectly.**

## Callbacks

Please note that at the moment (June 2025) go (1.24) does not support passing annonymous functions to C via CGO.
We have a workaround - pre-generating large amount of global functions and a pool.
For details see https://github.com/AllenDang/cimgui-go/issues/224.
Just be aware of the limitation that you may run out of pre-generated pool and experience a crash.

## Function coverage
Currently most of the functions are generated, except memory related stuff (eg. memory allocator, storage management, etc...).
If you find any function is missing, report an issue.

# Contribution
All kinds of contributions are welcome!

> [!warning]
> You will **NEVER** want to modify auto-generated files manually! (sufficient comments are placed on top of each file)
> All Pull Requests violating this rule will not pass automatic checks and will not be merged.

## Current solution is:
1. Use [cimgui](https://github.com/cimgui/cimgui)'s lua generator to generate function and struct definition as json.
2. Generate proper go code from the definition ([via manual crafted go program](./cmd/codegen)).
3. Use [the backend implementation](#supported-backends) from imgui.
4. Use github workflow to compile cimgui, glfw and other C dependencies to static lib and place them in ./lib folder for further link. 

Your contributions may apply to several areas:

## Code generation

A way  the actual binding is generated.
Such a modifications should be made in `cmd/codegen` module.
> [!tip]
> It is recommended to commit code re-generation separately from codegen modifications (however this is not a rule).

To actually generate Go binding, you need the following setup:
- Install [GNU make](https://www.gnu.org/software/make/manual/make.html)
- You'll also need Go :smile:

Then, just run `make`, or `make XXX` where `XXX` is the name of a package you want to generate (e.g. `make imgui`, `make implot`, etc.).

## Hardcoded bindings

There are some files in the wrapper that have been hardcoded and are not auto-generated. These include (but are not limited to):
- `imgui/extra_types.go`
- `imgui/extra_types.h`
- `imgui/clipboard.go`

> [!note]
> These files cuold be safely modified if you think they should be.

Same applies to the `backend/` packages.

## Updating plugins

We have a special system to make it easier to update dependencies. In order to issue an update, do the following:
- Make sure you have luajit installed on your system.
- Run `make update`. This will take a while as it will redownload all dependencies and regenerate the whole C and Go bindings.
- Commit your changes and push them to GitHub.
- Execute cimgui compilation as described below:

<details><summary>How to run cimgui compilation on GitHub</summary>

![preview](./docs/contribution_guide.png)

1. Go to your fork
2. Navigate to the "Actions" tab
3. Select "Compile cimgui" workflow tab
4. Click on "Run workflow" button
5. Select the branch you want to run the workflow on
6. Click "Run workflow" button

</details>

### Pre-compile code locally

> [!warning]
> **Do not** push pre-compiled code from your local machine! This may contain your local paths and you might not want to share them with the world. Let GitHub Actions do the compilation.

As GitHub Actions are a bit slow sometimes, this might be useful to speed-up development process on your local machine.
To pre-compile code locally, do the following:
- Make sure you have `cmake` as well as appropiate C/C++ toolchain installed on your system.
- Enter the `lib` directory.
- Run `cmake -Bbuild .`
- Then, `cd build` and run `make -j$(nproc)` to compile all imgui libraries.
- Copy `cimgui.a` to `lib/<your operatign system>/<your architecture>/cimgui.a`

## Pre-compiled code

To speed-up final Go build process, we pre-compile C/C++ libraries and place them in `libs/` directory.

These libraries are:
- ImGui and all its plugins (implot, imnodes, e.t.c.)
- GLFW, SDL2 backend components.

This unfortunately means that some operating systems will not work out of the box.
Currently, we compile against the following operating systems:
- macOS (arm64/x86_64)
- Windows (x86_64)
- Linux (x86_64)

If you run any system that is not listed above, you will need to compile the libraries yourself before using cimgui-go.
[Follow these instructions.](#pre-compile-code-locally). If you succeeded, please let us know by opening an issue (or a pull request) so we can try to add support for your system.

> [!important]
> Pre-compiled shared library is linked in files called `cflags.go`. You can find a global template in `templates/cflags.go.template`. After modifying it, just run a normal generation and it should update everywhere.

# Gallery

![App demo](./docs/app_demo.png)


cimgui-go

Cross-platform based on LCL(Native System UI Control Library) and CEF(Chromium Embedded Framework) (Windows/ macOS / Linux)

<p align="center">
    <img src="https://energye.github.io/imgs/energy.png">
</p>

<p align="center" style="font-size: 24px;">
    <strong>
        Energy is a GUI framework developed by Go, based on LCL and CEF
    </strong>
</p>

[中文](README.zh_CN.md) |
English

---

![go-version](https://img.shields.io/github/go-mod/go-version/energye/energy?logo=git&logoColor=green)
[![github](https://img.shields.io/github/last-commit/energye/energy/main.svg?logo=github&logoColor=green&label=commit)](https://github.com/energye/energy)
[![release](https://img.shields.io/github/v/release/energye/energy?logo=git&logoColor=green)](https://github.com/energye/energy/releases)
![Build Status](https://github.com/energye/energy/actions/workflows/build-test.yml/badge.svg)
![repo](https://img.shields.io/github/repo-size/energye/energy.svg?logo=github&logoColor=green&label=repo-size)
[![Go Report](https://goreportcard.com/badge/github.com/energye/energy)](https://goreportcard.com/report/github.com/energye/energy/v2)
[![Go Reference](https://pkg.go.dev/badge/github.com/energye/energy)](https://pkg.go.dev/github.com/energye/energy/v2)
[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/energye/energy)
[![Discord](https://img.shields.io/discord/1303173966747271209)](https://discord.gg/TejjxKz9)
[![codecov](https://codecov.io/gh/energye/energy/graph/badge.svg?token=H370UFUF12)](https://codecov.io/gh/energye/energy)
[![contributors](https://img.shields.io/github/contributors/energye/energy)](https://github.com/energye/energy/graphs/contributors)
[![license](https://img.shields.io/github/license/energye/energy.svg?logo=git&logoColor=red)](http://www.apache.org/licenses/LICENSE-2.0)
---


### [Project Introduction](https://energye.github.io/en/course/what-is-energy)

- Energy is a GUI framework developed in Go, based on [LCL](https://gitlab.com/freepascal.org/lazarus/lazarus) and [CEF](https://bitbucket.org/chromiumembedded/cef)(Chromium Embedded Framework), which is used to develop cross-platform desktop applications for Windows, MacOS, and Linux.
- LCL alone can create lightweight native applications, or can be combined with CEF to create more feature-complete applications.
- Construct cross-platform desktop applications that support Windows, Linux, and MacOS using Go and web technologies (HTML + CSS + JavaScript).

### Characteristic

- Rich CEF API and LCL system native widgets
- Development environment is simple and the compilation speed is fast. Only need Go and Energy.
- Cross-Platform: You can package your code as Windows, domestic UOS, Deepin, Kylin, MacOS and Linux
- Responsibilities
  - Go: Go is responsible for creating Windows, configuring CEF and implementing functions, creating various UI components, calling the low level of the system and some functions that JS cannot handle, such as: file flow, security encryption, high-performance processing, etc.
  - Web: HTML + CSS + JavaScript is responsible for the function of the client interface, you can make any interface you want.
- Front-end technology: Support mainstream frameworks, such as Vue, React, Angular or pure HTML+CSS+JS.
- Event driven: High performance event driven communication based on IPC allowing intercommunication between Go and Web.
- Resource loading: You can either read local resources or resources built into execution files either with or without HTTP services.

### ENERGY New 3.0
- [ENERGY GUI Designer](https://github.com/energye/designer)


### Built-in dependency&integration

- [![LCL](https://img.shields.io/badge/LCL-green)](https://github.com/energye/golcl)
- [![CEF-CEF4Delphi](https://img.shields.io/badge/CEF(Chromium%20Embedded%20Framework)%20CEF4Delphi-green)](https://github.com/salvadordf/CEF4Delphi)

### [Development Environment](https://energye.github.io/en/course/getting-started)

#### Basic needs

- Golang >= 1.18
- Energy (CEF, liblcl)

#### Environmental installation

Automatic installation development environment using the energy [command-line tool](https://energye.github.io/en/course/cli-use/)

### Guide to Start - [Link](https://energye.github.io/en/course/getting-started)

- [Guide](https://energye.github.io/en/course/getting-started)
- [Example](https://energye.github.io/en/examples)
- [Document](https://energye.github.io/en/document)

### Quick Start

- [Getting Started](https://energye.github.io/en/course/getting-started)

### Run a simple application by three steps

1. Install development environment: `energy install`
2. Initiate an Application: `energy init`
3. Run the Application: `go run main.go`

### sample code

main.go

```go
package main

import (
    "github.com/energye/energy/v2/cef"
)

func main() {
     //Global initialization
     cef.GlobalInit(nil, nil)
     //Create an application
     app := cef.NewApplication()
     //Specify a URL address or local HTML file directory
     cef.BrowserWindow.Config.Url = "https://energye.github.io"
     //Run Application
     cef.Run(app)
}
```

### Build

1. Build：`energy build`
2. Package：`energy package`
3. Package Type：
    - windows: Using `nsis` create exe installation package
    - linux: Using `dpkg` create deb installation package
    - macos: Generate `xxx.app`

### [System support](https://energye.github.io/en/document/version-details)

![Windows](https://img.shields.io/badge/Windows-✔️-success.svg?logo=Windows&logoColor=blue)
![MacOS](https://img.shields.io/badge/MacOS-✔️-success.svg?logo=MacOS)
![Linux](https://img.shields.io/badge/Linux-✔️-success.svg?logo=Linux&logoColor=red)

| OS                    | 32-bit | 64-bit |
|-----------------------|--------|--------|
| Windows               | ️✔️    | ️✔️    |
| MacOSX (Intel)        | ❌      | ️✔️    |
| MacOS (Apple Silicon) | ❌      | ️✔️    |
| Linux                 | ️✔️    | ️✔️    |
| Linux ARM             | ️✔️    | ️✔️    |

### v3.0 Related Projects
- [LCL](https://github.com/energye/lcl)
- [CEF](https://github.com/energye/cef)
- [Webview2 Webkit2](https://github.com/energye/wv)

### Other Projects

- [CEF(Chromium Embedded Framework)](https://github.com/chromiumembedded/cef)
- [CEF4Delphi](https://github.com/salvadordf/CEF4Delphi)
- [CefSharp](https://github.com/cefsharp/CefSharp)
- [Java-CEF](https://bitbucket.org/chromiumembedded/java-cef)
- [cefpython](https://github.com/cztomczak/cefpython)
- [Chromium](https://chromium.googlesource.com/chromium/src/)

---

### ENERGY QQ Group & WeChat

**Innovative functions break through difficulties. Light up the `star` and strive forward together!**

---

<p align="center">
    <img src="https://energye.github.io/imgs/assets/qq-group.jpg" width="250" title="QQ Group: 541258627" alt="QQ Group: 541258627">
    <img src="https://energye.github.io/imgs/assets/we-chat.jpg" width="250" title="WeChat: sniawmdf" alt="WeChat: sniawmdf" style="margin-left: 30px;">
</p>

---

### Thanks Jetbrains

<p align="center">
    <a href="https://www.jetbrains.com?from=energy">
        <img src="https://resources.jetbrains.com/storage/products/company/brand/logos/jb_beam.svg" alt="JetBrains Logo (Main) logo.">
    </a>
</p>

---

### Project screenshot

##### Windows-10

<img src="https://energye.github.io/imgs/readme/frameless-windows-10.png">

##### Windows-7 32 & 64

<img src="https://energye.github.io/imgs/readme/frameless-windows-7-64.png">
<img src="https://energye.github.io/imgs/readme/frameless-windows-7-32.png">

##### Windows-XP-SP3

<img src="https://energye.github.io/imgs/readme/windows-xp-sp3.png">

##### Linux - Deepin

<img src="https://energye.github.io/imgs/readme/frameless-deepin-20.8.png">
<img src="https://energye.github.io/imgs/readme/frameless-deepin-hide-20.8.png">

##### Linux - Kylin ARM

<img src="https://energye.github.io/imgs/readme/frameless-kylin-arm-V10-SP1.png">
<img src="https://energye.github.io/imgs/readme/frameless-kylin-arm-hide-V10-SP1.png">

##### Linux - Ubuntu

<img src="https://energye.github.io/imgs/readme/frameless-ubuntu-18.04.6.png">
<img src="https://energye.github.io/imgs/readme/frameless-ubuntu-hide-18.04.6.png">

##### MacOSX

<img src="https://energye.github.io/imgs/readme/frameless-macos.png">

----

### Public License

[![license](https://img.shields.io/github/license/energye/energy.svg?logo=git&logoColor=green)](http://www.apache.org/licenses/LICENSE-2.0)

### Contributors

<a href="https://github.com/energye/energy/graphs/contributors">
    <img src="https://opencollective.com/energy/contributors.svg?width=890&button=false" />
</a>


energy

Cross platform native GUIs designed for Go based on Material Design. Supports: Linux, macOS, Windows, BSD, iOS and Android

<p align="center">
  <a href="https://pkg.go.dev/fyne.io/fyne/v2?tab=doc" title="Go API Reference" rel="nofollow"><img src="https://img.shields.io/badge/go-documentation-blue.svg?style=flat" alt="Go API Reference"></a>
  <a href="https://img.shields.io/github/v/release/fyne-io/fyne?include_prereleases" title="Latest Release" rel="nofollow"><img src="https://img.shields.io/github/v/release/fyne-io/fyne?include_prereleases" alt="Latest Release"></a>
  <a href='https://gophers.slack.com/messages/fyne'><img src='https://img.shields.io/badge/join-us%20on%20slack-gray.svg?longCache=true&logo=slack&colorB=blue' alt='Join us on Slack' /></a>
  <br />
  <a href="https://goreportcard.com/report/fyne.io/fyne/v2"><img src="https://goreportcard.com/badge/fyne.io/fyne/v2" alt="Code Status" /></a>
  <a href="https://github.com/fyne-io/fyne/actions"><img src="https://github.com/fyne-io/fyne/workflows/Platform%20Tests/badge.svg" alt="Build Status" /></a>
  <a href='https://coveralls.io/github/fyne-io/fyne?branch=develop'><img src='https://coveralls.io/repos/github/fyne-io/fyne/badge.svg?branch=develop' alt='Coverage Status' /></a>
</p>

# About

[Fyne](https://fyne.io) is an easy-to-use UI toolkit and app API written in Go.
It is designed to build applications that run on desktop and mobile devices with a
single codebase.

# Prerequisites

To develop apps using Fyne you will need Go version 1.17 or later, a C compiler and your system's development tools.
If you're not sure if that's all installed or you don't know how then check out our
[Getting Started](https://fyne.io/develop/) document.

Using the standard go tools you can install Fyne's core library using:

    go get fyne.io/fyne/v2@latest

After importing a new module, run the following command before compiling the code for the first time. Avoid running it before writing code that uses the module to prevent accidental removal of dependencies:

    go mod tidy

# Widget demo

To run a showcase of the features of Fyne execute the following:

    go install fyne.io/demo@latest
    demo

And you should see something like this (after you click a few buttons):

<p align="center" markdown="1" style="max-width: 100%">
  <img src="img/widgets-dark.png" width="752" alt="Fyne Demo Dark Theme" style="max-width: 100%" />
</p>

Or if you are using the light theme:

<p align="center" markdown="1" style="max-width: 100%">
  <img src="img/widgets-light.png" width="752" alt="Fyne Demo Light Theme" style="max-width: 100%" />
</p>

And even running on a mobile device:

<p align="center" markdown="1" style="max-width: 100%">
  <img src="img/widgets-mobile-light.png" width="348" alt="Fyne Demo Mobile Light Theme" style="max-width: 100%" />
</p>

# Getting Started

Fyne is designed to be really easy to code with.
If you have followed the prerequisite steps above then all you need is a
Go IDE (or a text editor).

Open a new file and you're ready to write your first app!

```go
package main

import (
	"fyne.io/fyne/v2/app"
	"fyne.io/fyne/v2/container"
	"fyne.io/fyne/v2/widget"
)

func main() {
	a := app.New()
	w := a.NewWindow("Hello")

	hello := widget.NewLabel("Hello Fyne!")
	w.SetContent(container.NewVBox(
		hello,
		widget.NewButton("Hi!", func() {
			hello.SetText("Welcome :)")
		}),
	))

	w.ShowAndRun()
}
```

And you can run that simply as:

    go run main.go

> [!NOTE]  
> The first compilation of Fyne on Windows _can_ take up to 10 minutes, depending on your hardware. Subsequent builds will be fast.

It should look like this:

<div align="center">
  <table cellpadding="0" cellspacing="0" style="margin: auto; border-collapse: collapse;">
    <tr style="border: none;"><td style="border: none;">
      <img src="img/hello-light.png" width="207" alt="Fyne Hello Dark Theme" />
    </td><td style="border: none;">
      <img src="img/hello-dark.png" width="207" alt="Fyne Hello Dark Theme" />
    </td></tr>
  </table>
</div>

## Run in mobile simulation

There is a helpful mobile simulation mode that gives a hint of how your app would work on a mobile device:

    go run -tags mobile main.go

Another option is to use `fyne` command, see [Packaging for mobile](#packaging-for-mobile).

# Installing

Using `go install` will copy the executable into your go `bin` dir.
To install the application with icons etc into your operating system's standard
application location you can use the fyne utility and the "install" subcommand.

    go install fyne.io/tools/cmd/fyne@latest
    fyne install

# Packaging for mobile

To run on a mobile device it is necessary to package up the application.
To do this we can use the fyne utility "package" subcommand.
You will need to add appropriate parameters as prompted, but the basic command is shown below.
Once packaged you can install using the platform development tools or the fyne "install" subcommand.

    fyne package -os android -appID my.domain.appname
    fyne install -os android

The built Android application can run either in a real device or an Android emulator.
However, building for iOS is slightly different.
If the "-os" argument is "ios", it is build only for a real iOS device.
Specify "-os" to "iossimulator" allows the application be able to run in an iOS simulator:

    fyne package -os ios -appID my.domain.appname
    fyne package -os iossimulator -appID my.domain.appname

# Preparing a release

Using the fyne utility "release" subcommand you can package up your app for release
to app stores and market places. Make sure you have the standard build tools installed
and have followed the platform documentation for setting up accounts and signing.
Then you can execute something like the following, notice the `-os ios` parameter allows
building an iOS app from macOS computer. Other combinations work as well :)

    $ fyne release -os ios -certificate "Apple Distribution" -profile "My App Distribution" -appID "com.example.myapp"

The above command will create a '.ipa' file that can then be uploaded to the iOS App Store.

# Documentation

More documentation is available at the [Fyne developer website](https://developer.fyne.io/) or on [pkg.go.dev](https://pkg.go.dev/fyne.io/fyne/v2?tab=doc).

# Examples

You can find many example applications in the [examples repository](https://github.com/fyne-io/examples/).
Alternatively a list of applications using fyne can be found at [our website](https://apps.fyne.io/).

# Shipping the Fyne Toolkit

All Fyne apps will work without pre-installed libraries, this is one reason the apps are so portable.
However, if looking to support Fyne in a bigger way on your operating system then you can install some utilities that help to make a more complete experience.

## Additional apps

It is recommended that you install the following additional apps:

| app           | go install                          | description                                                            |
| ------------- | ----------------------------------- | ---------------------------------------------------------------------- |
| fyne_settings | `fyne.io/fyne/v2/cmd/fyne_settings` | A GUI for managing your global Fyne settings like theme and scaling    |
| apps          | `github.com/fyne-io/apps`           | A graphical installer for the Fyne apps listed at https://apps.fyne.io |

These are optional applications but can help to create a more complete desktop experience.

## FyneDesk (Linux / BSD)

To go all the way with Fyne on your desktop / laptop computer you could install [FyneDesk](https://github.com/fyshos/fynedesk) as well :)

![FyneDesk screenshopt in dark mode](https://fyshos.com/img/desktop.png)


fyne

gotk3 [![GoDoc](https://godoc.org/github.com/gotk3/gotk3?status.svg)](https://godoc.org/github.com/gotk3/gotk3)
=====

[![Build Status](https://travis-ci.org/gotk3/gotk3.svg?branch=master)](https://travis-ci.org/gotk3/gotk3)

The gotk3 project provides Go bindings for GTK 3 and dependent
projects.  Each component is given its own subdirectory, which is used
as the import path for the package.  Partial binding support for the
following libraries is currently implemented:

- GTK 3 (3.12 and later)
- GDK 3 (3.12 and later)
- GLib 2 (2.36 and later)
- Cairo (1.10 and later)

Care has been taken for memory management to work seamlessly with Go's
garbage collector without the need to use or understand GObject's
floating references.

for better understanding see
[package reference documation](https://pkg.go.dev/github.com/gotk3/gotk3/gtk?tab=doc)

On Linux, see which version your distribution has [here](https://pkgs.org) with the search terms:
* libgtk-3
* libglib2
* libgdk-pixbuf2

## Sample Use

The following example can be found in [Examples](https://github.com/gotk3/gotk3-examples/).

```Go
package main

import (
    "github.com/gotk3/gotk3/gtk"
    "log"
)

func main() {
    // Initialize GTK without parsing any command line arguments.
    gtk.Init(nil)

    // Create a new toplevel window, set its title, and connect it to the
    // "destroy" signal to exit the GTK main loop when it is destroyed.
    win, err := gtk.WindowNew(gtk.WINDOW_TOPLEVEL)
    if err != nil {
        log.Fatal("Unable to create window:", err)
    }
    win.SetTitle("Simple Example")
    win.Connect("destroy", func() {
        gtk.MainQuit()
    })

    // Create a new label widget to show in the window.
    l, err := gtk.LabelNew("Hello, gotk3!")
    if err != nil {
        log.Fatal("Unable to create label:", err)
    }

    // Add the label to the window.
    win.Add(l)

    // Set the default window size.
    win.SetDefaultSize(800, 600)

    // Recursively show all widgets contained in this window.
    win.ShowAll()

    // Begin executing the GTK main loop.  This blocks until
    // gtk.MainQuit() is run.
    gtk.Main()
}
```

To build the example:

```shell
$ go build example.go
```

To build this example with older gtk version you should use gtk_3_10 tag:

```shell
$ go build -tags gtk_3_10 example.go
```

### Example usage

```Go
package main

import (
    "log"
    "os"

    "github.com/gotk3/gotk3/glib"
    "github.com/gotk3/gotk3/gtk"
)

// Simple Gtk3 Application written in go.
// This application creates a window on the application callback activate.
// More GtkApplication info can be found here -> https://wiki.gnome.org/HowDoI/GtkApplication

func main() {
    // Create Gtk Application, change appID to your application domain name reversed.
    const appID = "org.gtk.example"
    application, err := gtk.ApplicationNew(appID, glib.APPLICATION_FLAGS_NONE)
    // Check to make sure no errors when creating Gtk Application
    if err != nil {
        log.Fatal("Could not create application.", err)
    }
    // Application signals available
    // startup -> sets up the application when it first starts
    // activate -> shows the default first window of the application (like a new document). This corresponds to the application being launched by the desktop environment.
    // open -> opens files and shows them in a new window. This corresponds to someone trying to open a document (or documents) using the application from the file browser, or similar.
    // shutdown ->  performs shutdown tasks
    // Setup Gtk Application callback signals
    application.Connect("activate", func() { onActivate(application) })
    // Run Gtk application
    os.Exit(application.Run(os.Args))
}

// Callback signal from Gtk Application
func onActivate(application *gtk.Application) {
    // Create ApplicationWindow
    appWindow, err := gtk.ApplicationWindowNew(application)
    if err != nil {
        log.Fatal("Could not create application window.", err)
    }
    // Set ApplicationWindow Properties
    appWindow.SetTitle("Basic Application.")
    appWindow.SetDefaultSize(400, 400)
    appWindow.Show()
}
```

```Go
package main

import (
    "log"
    "os"

    "github.com/gotk3/gotk3/glib"
    "github.com/gotk3/gotk3/gtk"
)

// Simple Gtk3 Application written in go.
// This application creates a window on the application callback activate.
// More GtkApplication info can be found here -> https://wiki.gnome.org/HowDoI/GtkApplication

func main() {
    // Create Gtk Application, change appID to your application domain name reversed.
    const appID = "org.gtk.example"
    application, err := gtk.ApplicationNew(appID, glib.APPLICATION_FLAGS_NONE)
    // Check to make sure no errors when creating Gtk Application
    if err != nil {
        log.Fatal("Could not create application.", err)
    }

    // Application signals available
    // startup -> sets up the application when it first starts
    // activate -> shows the default first window of the application (like a new document). This corresponds to the application being launched by the desktop environment.
    // open -> opens files and shows them in a new window. This corresponds to someone trying to open a document (or documents) using the application from the file browser, or similar.
    // shutdown ->  performs shutdown tasks
    // Setup activate signal with a closure function.
    application.Connect("activate", func() {
        // Create ApplicationWindow
        appWindow, err := gtk.ApplicationWindowNew(application)
        if err != nil {
            log.Fatal("Could not create application window.", err)
        }
        // Set ApplicationWindow Properties
        appWindow.SetTitle("Basic Application.")
        appWindow.SetDefaultSize(400, 400)
        appWindow.Show()
    })
    // Run Gtk application
    application.Run(os.Args)
}
```

## Documentation

Each package's internal `go doc` style documentation can be viewed
online without installing this package by using the GoDoc site (links
to [cairo](http://godoc.org/github.com/gotk3/gotk3/cairo),
[glib](http://godoc.org/github.com/gotk3/gotk3/glib),
[gdk](http://godoc.org/github.com/gotk3/gotk3/gdk), and
[gtk](http://godoc.org/github.com/gotk3/gotk3/gtk) documentation).

You can also view the documentation locally once the package is
installed with the `godoc` tool by running `godoc -http=":6060"` and
pointing your browser to
http://localhost:6060/pkg/github.com/gotk3/gotk3

## Installation

gotk3 currently requires GTK 3.6-3.24, GLib 2.36-2.46, and
Cairo 1.10 or 1.12.  A recent Go (1.8 or newer) is also required.

For detailed instructions see the wiki pages: [installation](https://github.com/gotk3/gotk3/wiki#installation)

## Using deprecated features

By default, deprecated GTK features are not included in the build.

By specifying the e.g. build tag `gtk_3_20`, any feature deprecated in GTK 3.20 or earlier will NOT be available.
To enable deprecated features in the build, add the tag `gtk_deprecated`.
Example:
```shell
$ go build -tags "gtk_3_10 gtk_deprecated" example.go
```

The same goes for
* gdk-pixbuf: gdk_pixbuf_deprecated

## TODO

- Add bindings for all of GTK functions
- Add tests for each implemented binding
- See the next steps: [wiki page](https://github.com/gotk3/gotk3/wiki/The-future-and-what-happens-next) and add [your suggestion](https://github.com/gotk3/gotk3/issues/576)


## License

Package gotk3 is licensed under the liberal ISC License.

Actually if you use gotk3, then gotk3 is statically linked into your application (with the ISC licence).
The system libraries (e.g. GTK+, GLib) used via cgo use dynamic linking.


gotk3

Rapid and simple desktop UI development with GO, HTML, CSS and NW.js. Cross platform

# gowd

Build cross platform GUI apps with GO and HTML/JS/CSS (powered by [nwjs](https://nwjs.io/))

[![CircleCI](https://circleci.com/gh/dtylman/gowd.svg?style=svg)](https://circleci.com/gh/dtylman/gowd)
[![Go Report Card](https://goreportcard.com/badge/github.com/dtylman/gowd)](https://goreportcard.com/report/github.com/dtylman/gowd)
[![GoDoc](https://godoc.org/github.com/dtylman/gowd?status.svg)](http://godoc.org/github.com/dtylman/gowd)

### How to use this library:

1. Download and install [nwjs](https://nwjs.io/)
1. Install this library `go get github.com/dtylman/gowd`
1. Clone this repo.
1. Place `package.json`, `index.html`, `main.go` and `main.js` from [template](cmd/template/) in a new folder. 
1. `go build`
1. Edit `main.js` and set `goBinary` to your your executable name:
    ```javascript
    var goBinary = "./template"; //or template.exe
    ```
1. Run `nw .`, the hello world template should appear:
![hello-world](cmd/template/hello-world.png)

### Usage

Simplest "hello world":
```go

import "github.com/dtylman/gowd"

func main() {
	body, err := gowd.ParseElement("<h1>Hello world</h1>", nil)
	if err != nil {
		panic(err)
	}
	gowd.Run(body)
}

```

Adding a button:

```go

import (
	"github.com/dtylman/gowd"
)

func main() {
	body, err := gowd.ParseElement("<h1>Hello world</h1>", nil)
	if err != nil {
		panic(err)
	}
	p := body.AddElement(gowd.NewElement("p"))
	btn := p.AddElement(gowd.NewElement("button"))
	btn.SetText("Click me")
	btn.OnEvent(gowd.OnClick, btnClicked)
	gowd.Run(body)
}

func btnClicked(sender *gowd.Element, event *gowd.EventElement) {
	sender.SetText("Clicked!")
}
```

Creating and binding from HTML:
```go
import (
	"github.com/dtylman/gowd"
	"fmt"
)

func main() {
	body, err := gowd.ParseElement("<h1>Hello world</h1>", nil)
	if err != nil {
		panic(err)
	}
	p := body.AddElement(gowd.NewElement("p"))
	em := gowd.NewElementMap()
	p.AddHtml(`<select id="select1">
		<option value="" disabled="disabled" selected="selected">Please select a name</option>
		<option value="1">One</option>
		<option value="2">Two</option>
		</select>`, em)
	em["select1"].OnEvent(gowd.OnChange, btnClicked)
	em["select1"].Object = body
	gowd.Run(body)
}

func btnClicked(sender *gowd.Element, event *gowd.EventElement) {
	body := sender.Object.(*gowd.Element)
	body.AddElement(gowd.NewStyledText(fmt.Sprintf("Selected %s", event.GetValue()), gowd.BoldText))
	body.AddElement(gowd.NewElement("br"))
}
```

Using bootstrap:

'gowd' supports creating bootstrap elements using the [bootstrap](bootstrap/) package.

First, add bootsrap css and js to your `index.html` file:
```html
    <script type="text/javascript" src="js/jquery.min.js"></script>
    <link rel="stylesheet" type="text/css" href="css/bootstrap.min.css"/>
    <script type="text/javascript" src="js/bootstrap.min.js"></script>
```

Then you can create bootsrap items:

```go

import (
	"github.com/dtylman/gowd"

	"github.com/dtylman/gowd/bootstrap"
	"time"
	"fmt"
)

var body *gowd.Element

func main() {
	//creates a new bootstrap fluid container
	body = bootstrap.NewContainer(false)
	// add some elements using the object model
	div := bootstrap.NewElement("div", "well")
	row := bootstrap.NewRow(bootstrap.NewColumn(bootstrap.ColumnLarge, 6, div))
	body.AddElement(row)
	// add some other elements from HTML
	div.AddHTML(`<div class="dropdown">
	<button class="btn btn-primary dropdown-toggle" type="button" data-toggle="dropdown">Dropdown Example
	<span class="caret"></span></button>
	<ul class="dropdown-menu" id="dropdown-menu">
	<li><a href="#">HTML</a></li>
	<li><a href="#">CSS</a></li>
	<li><a href="#">JavaScript</a></li>
	</ul>
	</div>`, nil)
	// add a button to show a progress bar
	btn := bootstrap.NewButton(bootstrap.ButtonPrimary, "Start")
	btn.OnEvent(gowd.OnClick, btnClicked)
	row.AddElement(bootstrap.NewColumn(bootstrap.ColumnLarge, 4, bootstrap.NewElement("div", "well", btn)))

	//start the ui loop
	gowd.Run(body)
}

// happens when the 'start' button is clicked
func btnClicked(sender *gowd.Element, event *gowd.EventElement) {
	// adds a text and progress bar to the body 
	text := body.AddElement(gowd.NewStyledText("Working...", gowd.BoldText))
	progressBar := bootstrap.NewProgressBar()
	body.AddElement(progressBar.Element)
	
	// makes the body stop responding to user events
	body.Disable()
	
	// clean up - remove the added elements
	defer func() {
		body.RemoveElement(text)
		body.RemoveElement(progressBar.Element)
		body.Enable()
	}()

	// render the progress bar
	for i := 0; i <= 123; i++ {
		progressBar.SetValue(i, 123)
		text.SetText(fmt.Sprintf("Working %v", i))
		time.Sleep(time.Millisecond * 20)
		// this will cause the body to be refreshed
		body.Render()
	}

}
```

This will yield the following app:

![Simple](docs/template.gif)

More a more advanced usage, see the [Todo](cmd/todomvc/readme.md) sample

![TodoMVC](docs/todomvc.gif)



gowd

Qt binding for Go (support for Windows / macOS / Linux / Android / iOS / Sailfish OS / Raspberry Pi)

Introduction
------------

[Qt](https://en.wikipedia.org/wiki/Qt_(software)) is a free and open-source widget toolkit for creating graphical user interfaces as well as cross-platform applications that run on various software and hardware platforms with little or no change in the underlying codebase.

[Go](https://en.wikipedia.org/wiki/Go_(programming_language)), also known as Golang, is a programming language designed at Google.

[therecipe/qt](https://github.com/therecipe/qt) allows you to write Qt applications entirely in Go, [JavaScript/TypeScript](https://github.com/therecipe/entry), [Dart/Flutter](https://github.com/therecipe/flutter), [Haxe](https://github.com/therecipe/haxe) and [Swift](https://github.com/therecipe/swift)

Beside the language bindings provided, `therecipe/qt` also greatly simplifies the deployment of Qt applications to various software and hardware platforms.

At the time of writing, almost all Qt functions and classes are accessible, and you should be able to find everything you need to build fully featured Qt applications.

Impressions
-----------

[Gallery](https://github.com/therecipe/qt/wiki/Gallery) of example applications.

[JavaScript Demo](https://therecipe.github.io/entry) | *[source](https://github.com/therecipe/entry)*

Installation
------------

The following instructions assume that you already installed [Go](https://golang.org/dl/) and [Git](https://git-scm.com/downloads)

#### (Experimental) cgo-less version (try this first, if you are new and want to test the binding)

##### Windows

```powershell
go get -ldflags="-w" github.com/therecipe/examples/basic/widgets && for /f %v in ('go env GOPATH') do %v\bin\widgets.exe
```

##### macOS/Linux

```bash
go get -ldflags="-w" github.com/therecipe/examples/basic/widgets && $(go env GOPATH)/bin/widgets
```

#### Default version

##### Windows [(more info)](https://github.com/therecipe/qt/wiki/Installation-on-Windows)

```powershell
set GO111MODULE=off
go get -v github.com/therecipe/qt/cmd/... && for /f %v in ('go env GOPATH') do %v\bin\qtsetup test && %v\bin\qtsetup -test=false
```

##### macOS [(more info)](https://github.com/therecipe/qt/wiki/Installation-on-macOS)

```bash
export GO111MODULE=off; xcode-select --install; go get -v github.com/therecipe/qt/cmd/... && $(go env GOPATH)/bin/qtsetup test && $(go env GOPATH)/bin/qtsetup -test=false
```

##### Linux [(more info)](https://github.com/therecipe/qt/wiki/Installation-on-Linux)

```bash
export GO111MODULE=off; go get -v github.com/therecipe/qt/cmd/... && $(go env GOPATH)/bin/qtsetup test && $(go env GOPATH)/bin/qtsetup -test=false
```

Resources
---------

-	[Installation](https://github.com/therecipe/qt/wiki/Installation)
-	[Getting Started](https://github.com/therecipe/qt/wiki/Getting-Started)
-	[Wiki](https://github.com/therecipe/qt/wiki)
-	[Qt Documentation](https://doc.qt.io/qt-5/classes.html)
-	[FAQ](https://github.com/therecipe/qt/wiki/FAQ)
-	[#qt-binding](https://gophers.slack.com/messages/qt-binding/details) Slack channel ([invite](https://invite.slack.golangbridge.org)\)

Deployment Targets
------------------

| Target                   | Arch             | Linkage                   | Docker Deployment | Host OS |
|:------------------------:|:----------------:|:-------------------------:|:-----------------:|:-------:|
|         Windows          |     32 / 64      |     dynamic / static      |        Yes        |   Any   |
|          macOS           |        64        |          dynamic          |        Yes        |   Any   |
|          Linux           | arm / arm64 / 64 | dynamic / static / system |        Yes        |   Any   |
|     Android (+Wear)      |   arm / arm64    |          dynamic          |        Yes        |   Any   |
| Android-Emulator (+Wear) |        32        |          dynamic          |        Yes        |   Any   |
|        SailfishOS        |       arm        |          system           |        Yes        |   Any   |
|   SailfishOS-Emulator    |        32        |          system           |        Yes        |   Any   |
|   Raspberry Pi (1/2/3)   |       arm        |     dynamic / system      |        Yes        |   Any   |
|       Ubuntu Touch       |     arm / 64     |          system           |        Yes        |   Any   |
|        JavaScript        |        32        |          static           |        Yes        |   Any   |
|       WebAssembly        |        32        |          static           |        Yes        |   Any   |
|           iOS            |      arm64       |          static           |        No         |  macOS  |
|      iOS-Simulator       |        64        |          static           |        No         |  macOS  |
|        AsteroidOS        |       arm        |          system           |        No         |  Linux  |
|         FreeBSD          |     32 / 64      |          system           |        No         | FreeBSD |

License
-------

This package is released under [LGPLv3](https://opensource.org/licenses/LGPL-3.0)

Qt itself is licensed and available under multiple [licenses](https://www.qt.io/licensing).


Reactive, cross-platform desktop GUI toolkit

<p style="text-align:center"><img src="./resources/2024-05-13-demo-video.gif" width="50%" height="50%" /></p>

# Spot

[![Build status](https://github.com/roblillack/spot/actions/workflows/go.yml/badge.svg?branch=main)](https://github.com/roblillack/spot/actions)
[![Go Reference](https://pkg.go.dev/badge/github.com/roblillack/spot.svg)](https://pkg.go.dev/github.com/roblillack/spot)
[![Go Report Card](https://goreportcard.com/badge/github.com/roblillack/spot)](https://goreportcard.com/report/github.com/roblillack/spot)

Spot is a simple, cross-platform, reactive GUI toolkit for Go using native
widgets where available. It is designed to be easy to use and to provide a
consistent API across different platforms.

## Example

```go
package main

import (
	"fmt"

	"github.com/roblillack/spot"
	"github.com/roblillack/spot/ui"
)

func main() {
	ui.Init()

	spot.MountFn(func(ctx *spot.RenderContext) spot.Component {
		counter, setCounter := spot.UseState[int](ctx, 0)

		buttonTitle := "Click me!"
		if counter > 0 {
			buttonTitle = fmt.Sprintf("Clicked %d times!", counter)
		}

		return &ui.Window{
			Title:  "Hello World!",
			Width:  200,
			Height: 125,
			Children: []spot.Component{
				&ui.Button{
					X: 25, Y: 50, Width: 150, Height: 25,
					Title: buttonTitle,
					OnClick: func() {
						setCounter(counter + 1)
					},
				},
			},
		}
	})

	ui.Run()
}
```

## Features

- **Simple**: You can add Spot as a simple dependency to your project and start
  building your UI right away. No need to use additional tools or code
  generation steps. Just write Go code and get a native GUI application as a
  self-contained binary.
- **Cross-platform**: Spot uses native widgets where available and
  automatically selects the best backend for the platform you are running on
  at compile time. Currently, two backend implementations are provided: one
  based on [FLTK](https://fltk.org) using
  [go-fltk](https://github.com/pwiecz/go-fltk) and one based on Cocoa using
  ([a modified version of](https://github.com/roblillack/gocoa))
  [gocoa](https://github.com/mojbro/gocoa).
- **Reactive**: Spot automatically updates the UI when the state of the
  application changes. You just provide side-effect free rendering functions
  and manage the state of your application using the [`UseState`](https://pkg.go.dev/github.com/roblillack/spot#UseState) hook.
- **Broad widget support**: Spot provides a wide range of UI controls out of
  the box, including buttons, labels, text inputs, sliders, dropdowns, and
  more. See the full list:
  [List of supported UI controls](#list-of-supported-ui-controls).

## FAQs

#### What does "reactive" mean?

In the context of Spot, _reactive_ means that the UI is automatically updated
when the state of the application changes. This is achieved by re-building an
immutable component tree upon state changes which can quickly be compared to
the previous state in order to determine what UI controls need to be updated.
In the web world, this idea is often called a "virtual DOM" and Spot actually
started as an experiment to bring this concept to Go by implementing a
React-like GUI library for the desktop.

By using a reactive model, the developer does not need to worry about updating
the UI manually. Instead, the developer can focus on the application logic and
let Spot take care of updating the UI.

#### What are the "native widgets" that Spot uses?

Currently, Spot uses a Cocoa backend on macOS and a FLTK-based one on all other
platforms. Optionally, FLTK can be used on the Mac, too. Better support for
Windows is planned for the future.

#### Can I implement my own hooks?

Yes, just like in React, you can implement your own hooks. Just create a
function which takes a `*spot.RenderContext` as first argument and use this to
"hook" into the Spot lifecycle by calling `spot.UseState`, `spot.UseEffect`,
etc. Convention here is to prefix the function with `Use…`.

#### How do I write custom components?

There are a few different ways to separate your UI into components in Spot;
for some ideas, check out the `custom-components` example. The main way to
write custom components is to create a struct that implements the
`spot.Component` interface. This interface has a single method,
`Render(ctx *spot.RenderContext) spot.Component`, which is called to render
the component. Components created like this can be used in the same way as
the built-in ones.

Look at the `BlinkingButton` component in the example to see how this is done.

#### Can I use Spot with a completely different widget library than the provided one?

Yes, you can. You just need to create some structs that implement the
`spot.Component` interface and which take care of managing the native widgets.

#### Can I use `spot/ui`, but with a different backend than Cocoa or FLTK?

Currently, these are the only backends that are supported. But feel free to
create a PR if you want to add support for another backend. _\*hint hint\*_

#### What's the difference between `spot/ui` and `spot`?

`spot` is the core package that provides the reactive model and the rendering
functionality. It is backend-agnostic and can be used with any set of controls
which implement the `spot.Control` interface.

`spot/ui` is a package that provides a set of pre-built cross-platform GUI
controls that which can be used with `spot`.

#### What's the difference between a “component” and a “control”?

In Spot, a _component_ is a logical unit of the application that contains
business logic and state. Any component is made out of other componens and
can ultimately be rendered down to a single or multiple "controls".

A _control_ is special kind component is mounted to the UI tree and represents
a visual element on the screen. Usually a control is backed by a native
implementation of the GUI backend, like a button, a label, or a text input.

#### What do the terms ”make”, “render”, “build”, “mount”, and “update” mean in the context of Spot?

- _Make_: The process of creating a new component instance. This is done by
  creating a reference to an instance of a struct that implements the
  `spot.Component` interface or by calling `spot.Make` with a render function.

- _Render_: The process of applying a component's state to its building blocks
  and hereby returning another component instance. This is done by calling the
  `Render` method on a component instance.

- _Build_: The process of creating a new UI tree from a component instance.
  This is done by _recursively_ rendering a component to create a tree of
  controls. This can be done by calling `spot.Build` with a component instance
  or `spot.BuildFn` with a render function.

- _Mount_: The process of creating real UI controls from a (virtual) tree of
  controls. This is done by calling `Mount` on a tree node or `spot.Mount` with
  a component instance or `spot.MountFn` with a render function.

- _Update_: The process of updating a tree of (mounted) controls. This is done
  by calling `Update` on a tree node.

## Features, Spot does not have right now

- Automatic layouting
- Multiple windows
- Modal dialogs
- Resizable windows
- Menu bars
- Custom widgets
- Access to native widgets
- Drag and drop
- Internationalization

## List of supported UI controls

Explanation of the status column: \
❓ Not implemented /
🚧 Work in progress /
⚠️ Partially implemented /
✅ Done

| Name                                                                        | Description                                                                                     | Native controls used                                                                                                                                                                                                                                            | Status      |
| --------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- |
| [Button](https://pkg.go.dev/github.com/roblillack/spot/ui#Button)           | Simple button to initiate an action                                                             | [Fl_Button](https://www.fltk.org/doc-1.4/classFl__Button.html) <br> [NSButton](https://developer.apple.com/documentation/appkit/nsbutton)                                                                                                                       | ✅          |
| [Checkbox](https://pkg.go.dev/github.com/roblillack/spot/ui#Checkbox)       | Control offering the user a choice between two mutually exclusive options                       | [Fl_Check_Button](https://www.fltk.org/doc-1.4/classFl__Check__Button.html) <br> [NSButton](https://developer.apple.com/documentation/appkit/nsbutton) ([NSButtonTypeSwitch](https://developer.apple.com/documentation/appkit/nsbuttontype/nsbuttontypeswitch)) | ✅          |
| ComboBox                                                                    | A combined dropdown menu with text input                                                        | ComboBox <br> NSComboBox                                                                                                                                                                                                                                        | Not started |
| [Dial](https://pkg.go.dev/github.com/roblillack/spot/ui#Dial)               | Circular status control                                                                         | [Fl_Dial](https://www.fltk.org/doc-1.4/classFl__Dial.html) <br> [NSProgressIndicator](https://developer.apple.com/documentation/appkit/nsprogressindicator) (with `NSCircular` style)                                                                           | ⚠️          |
| [Dropdown](https://pkg.go.dev/github.com/roblillack/spot/ui#Dropdown)       | Drop-down menu to select a single item out of multiple options                                  | [Fl_Choice](https://www.fltk.org/doc-1.4/classFl__Choice.html) <br> [NSComboBox](https://developer.apple.com/documentation/appkit/nscombobox)                                                                                                                   | ✅          |
| [Image](https://pkg.go.dev/github.com/roblillack/spot/ui#Image)             | Control to display bitmap images on                                                             | [Fl_Box](https://www.fltk.org/doc-1.4/classFl__Box.html) <br> custom [NSButton](https://developer.apple.com/documentation/appkit/nsbutton)                                                                                                                      | ✅          |
| [Label](https://pkg.go.dev/github.com/roblillack/spot/ui#Label)             | Simple, non-editable text label                                                                 | [Fl_Box](https://www.fltk.org/doc-1.4/classFl__Box.html) <br> [NSTextField](https://developer.apple.com/documentation/appkit/nstextfield)                                                                                                                       | ✅          |
| [ListBox](https://pkg.go.dev/github.com/roblillack/spot/ui#ListBox)         | Scrollable control which allows the user to select a single or multible items from a given list | [Fl_Select_Browser](https://www.fltk.org/doc-1.4/classFl__Select__Browser.html)/[Fl_Multi_Browser](https://www.fltk.org/doc-1.4/classFl__Multi__Browser.html)<br> [NSTableView](https://developer.apple.com/documentation/appkit/nstableview)                   | ✅          |
| [ProgressBar](https://pkg.go.dev/github.com/roblillack/spot/ui#ProgressBar) | Progress bar control to visualize the progression of a long-running operation                   | [Fl_Progress](https://www.fltk.org/doc-1.4/classFl__Progress.html) <br> [NSProgressIndicator](https://developer.apple.com/documentation/appkit/nsprogressindicator)                                                                                             | ✅          |
| [Slider](https://pkg.go.dev/github.com/roblillack/spot/ui#Slider)           | Horizontal slider input control                                                                 | [Fl_Slider](https://www.fltk.org/doc-1.4/classFl__Slider.html) <br> [NSSlider](https://developer.apple.com/documentation/appkit/nsslider)                                                                                                                       | ✅          |
| [Spinner](https://pkg.go.dev/github.com/roblillack/spot/ui#Spinner)         | Number input control with up/down buttons                                                       | [Fl_Spinner](https://www.fltk.org/doc-1.4/classFl__Spinner.html) <br> [NSTextField](https://developer.apple.com/documentation/appkit/nstextfield)+[NSStepper](https://developer.apple.com/documentation/appkit/nsstepper)                                       | ✅          |
| [TextField](https://pkg.go.dev/github.com/roblillack/spot/ui#TextField)     | Control for single-line text input                                                              | [Fl_Input](https://www.fltk.org/doc-1.4/classFl__Input.html) <br> [NSTextField](https://developer.apple.com/documentation/appkit/nstextfield)                                                                                                                   | ✅          |
| [TextEditor](https://pkg.go.dev/github.com/roblillack/spot/ui#TextEditor)   | General-purpose text box to edit multi-line text content                                        | [Fl_Text_Editor](https://www.fltk.org/doc-1.4/classFl__Text__Editor.html) <br> [NSTextView](https://developer.apple.com/documentation/appkit/nstextview)                                                                                                        | ✅          |
| [Window](https://pkg.go.dev/github.com/roblillack/spot/ui#Window)           | Control representing a (top-level) window on the screen                                         | [Fl_Window](https://www.fltk.org/doc-1.4/classFl__Window.html) <br> [NSWindow](https://developer.apple.com/documentation/appkit/nswindow)                                                                                                                       | ✅          |

## Potential future backends to look at

- Native Windows controls: https://github.com/rodrigocfd/windigo


Spot

Platform-native GUI library for Go. Cross platform

# ui: platform-native GUI library for Go

This is a library that aims to provide simple GUI software development in Go. It is based on my [libui](https://github.com/andlabs/libui), a simple cross-platform library that does the same thing, but written in C.

It runs on/requires:

- Windows: cgo, Windows Vista SP2 with Platform Update and newer
- Mac OS X: cgo, Mac OS X 10.8 and newer
- other Unixes: cgo, GTK+ 3.10 and newer
	- Debian, Ubuntu, etc.: `sudo apt-get install libgtk-3-dev`
	- Red Hat/Fedora, etc.: `sudo dnf install gtk3-devel`

It also requires Go 1.8 or newer.

It currently aligns to libui's Alpha 4.1, with only a small handful of functions not available.

# Status

Package ui is currently **mid-alpha** software. Much of what is currently present runs stabily enough for the examples and perhaps some small programs to work, but the stability is still a work-in-progress, much of what is already there is not feature-complete, some of it will be buggy on certain platforms, and there's a lot of stuff missing. The libui README has more information.

# Installation

Once you have the dependencies installed, a simple

```
go get github.com/andlabs/ui/...
```

should suffice.

# Documentation

The in-code documentation is sufficient to get started, but needs improvement.

Some simple example programs are in the `examples` directory. You can `go build` each of them individually.

## Windows manifests

Package ui requires a manifest that specifies Common Controls v6 to run on Windows. It should at least also state as supported Windows Vista and Windows 7, though to avoid surprises with other packages (or with Go itself; see [this issue](https://github.com/golang/go/issues/17835)) you should state compatibility with higher versions of Windows too.

The simplest option is provided as a subpackage `winmanifest`; you can simply import it without a name, and it'll set things up properly:

```go
import _ "github.com/andlabs/ui/winmanifest"
```

You do not have to worry about importing this in non-Windows-only files; it does nothing on non-Windows platforms.

If you wish to use your own manifest instead, you can use the one in `winmanifest` as a template to see what's required and how. You'll need to specify the template in a `.rc` file and use `windres` in MinGW-w64 to generate a `.syso` file as follows:

```
windres -i resources.rc -o winmanifest_windows_GOARCH.syso -O coff
```

You may also be interested in the `github.com/akavel/rsrc` and `github.com/josephspurrier/goversioninfo` packages, which provide other Go-like options for embedding the manifest.

Note that if you choose to ship a manifest as a separate `.exe.manifest` file instead of embedding it in your binary, and you use Cygwin or MSYS2 as the source of your MinGW-w64, Cygwin and MSYS2 instruct gcc to embed a default manifest of its own if none is specified. **This default will override your manifest file!** See [this issue](https://github.com/Alexpux/MSYS2-packages/issues/454) for more details, including workaround instructions.

## macOS program execution

If you run a macOS program binary directly from the command line, it will start in the background. This is intentional; see [this](https://github.com/andlabs/libui#why-does-my-program-start-in-the-background-on-os-x-if-i-run-from-the-command-line) for more details.


A unified graphical user experience toolkit for Go desktop applications. macOS, Windows, and Linux are supported

# Unison

[![Go Reference](https://pkg.go.dev/badge/github.com/richardwilkes/unison.svg)](https://pkg.go.dev/github.com/richardwilkes/unison)
[![Go Report Card](https://goreportcard.com/badge/github.com/richardwilkes/unison)](https://goreportcard.com/report/github.com/richardwilkes/unison)

A unified graphical user experience toolkit for Go desktop applications. macOS, Windows, and Linux are supported.

## Required setup

Unison is built upon [glfw](https://github.com/go-gl/glfw). As such, it requires some setup prior to being able to build
correctly:

* On macOS, you need Xcode or Command Line Tools for Xcode (`xcode-select --install`) for required headers and
  libraries.
* On Ubuntu/Debian-like Linux distributions, you need `libgl1-mesa-dev` and `xorg-dev` packages.
* On CentOS/Fedora-like Linux distributions, you need `libX11-devel libXcursor-devel libXrandr-devel libXinerama-devel
  mesa-libGL-devel libXi-devel libXxf86vm-devel` packages.
* On Windows, you need [tdm-gcc](https://jmeubank.github.io/tdm-gcc/download/) as well as [git-scm](https://git-scm.com)
  for its bash shell.
* See [compilation dependencies](http://www.glfw.org/docs/latest/compile.html#compile_deps) for full details.

This version of Unison was built using Go 1.24. It has been compiled under many earlier versions of Go in the past, but
only Go 1.24+ will be considered as I make further changes.

## Example

An example application can be found in the `cmd/example` directory:

```sh
go run ./cmd/example/main.go
```

## Notes

Unison was developed with the needs of my personal projects in mind, so may not be a good fit for your particular needs.
I'm open to suggestions on ways to improve the code and will happily consider Pull Requests with bug fixes or feature
additions.

### Compatibility

Unison is very much a work in progress. As such, it is likely to have breaking changes. To reflect this, a version
number of 0.x.x will be in use until such time that I'm comfortable locking things down to ensure compatibility between
releases. Please keep this in mind when making the decision to use Unison in your own code.

### Look & Feel

Unison defines its own look and feel for widgets and will likely be adjusted over time. This was done to provide as much
consistency as possible between all supported platforms. It also side-steps issues where a given platform itself has no
or poorly defined standards. Colors, fonts, spacing, how the widgets behave, and more are customizable, so if you are
feeling particularly ambitious, you could create your own theming that matches a given platform.

### Organization

There are a large number of Go source files in a single, top-level package. Unison didn't start out this way, but user
experience code tends to need to have its tentacles in many places, and the logical separations I made kept hindering
the ability to do things. Ultimately, I made the decision to collapse nearly everything into a single package to
simplify development and greatly reduce the overall complexity of things.


unison

walk

Cross-platform webview window with simple two-way JavaScript bindings (Windows / macOS / Linux)

webview

gosx-notifier
===========================
A [Go](http://golang.org) lib for sending desktop notifications to OSX Mountain Lion's (10.8 or higher REQUIRED)
[Notification Center](http://www.macworld.com/article/1165411/mountain_lion_hands_on_with_notification_center.html).

[![GoDoc](http://godoc.org/github.com/deckarep/gosx-notifier?status.png)](http://godoc.org/github.com/deckarep/gosx-notifier)

Update 4/3/2014
------
On OSX 10.9 and above gosx-notifier now supports images and icons.
![Now with custom icon support](../master/example.png?raw=true)

Synopsis
--------
OSX Mountain Lion comes packaged with a built-in notification center. For whatever reason, [Apple sandboxed the
notification center API](http://forums.macrumors.com/showthread.php?t=1403807) to apps hosted in its App Store. The end
result? A potentially useful API shackled to Apple's ecosystem.

Thankfully, [Eloy Durán](https://github.com/alloy) put together [an osx app](https://github.com/alloy/terminal-notifier) that allows terminal access to the sandboxed API. **gosx-notifier** embeds this app with a simple interface to the closed API.

It's not perfect, and the implementor will quickly notice its limitations. However, it's a start and any pull requests are accepted and encouraged!

Dependencies:
-------------
There are none! If you utilize this package and create a binary executable it will auto-magically install the terminal-notifier component into a temp directory of the server.  This is possible because in this latest version the terminal-notifier binary is now statically embedded into the Go source files.


Installation and Requirements
-----------------------------
The following command will install the notification api for Go along with the binaries.  Also, utilizing this lib requires OSX 10.8 or higher. It will simply not work on lower versions of OSX.

```sh
go get github.com/deckarep/gosx-notifier
```

Using the Command Line
-------------
```Go
notify "Wow! A notification!!!"
```

useful for knowing when long running commands finish

```Go
longRunningCommand && notify done!
```

Using the Code
------------------
It's a pretty straightforward API:

```Go
package main

import (
    "github.com/deckarep/gosx-notifier"
    "log"
)

func main() {
    //At a minimum specifiy a message to display to end-user.
    note := gosxnotifier.NewNotification("Check your Apple Stock!")

    //Optionally, set a title
    note.Title = "It's money making time 💰"

    //Optionally, set a subtitle
    note.Subtitle = "My subtitle"

    //Optionally, set a sound from a predefined set.
    note.Sound = gosxnotifier.Basso

    //Optionally, set a group which ensures only one notification is ever shown replacing previous notification of same group id.
    note.Group = "com.unique.yourapp.identifier"

    //Optionally, set a sender (Notification will now use the Safari icon)
    note.Sender = "com.apple.Safari"

    //Optionally, specifiy a url or bundleid to open should the notification be
    //clicked.
    note.Link = "http://www.yahoo.com" //or BundleID like: com.apple.Terminal

    //Optionally, an app icon (10.9+ ONLY)
    note.AppIcon = "gopher.png"

    //Optionally, a content image (10.9+ ONLY)
    note.ContentImage = "gopher.png"

    //Then, push the notification
    err := note.Push()

    //If necessary, check error
    if err != nil {
        log.Println("Uh oh!")
    }
}
```

Sample App: Desktop Pinger Notification - monitors your websites and will notifiy you when a website is down.
```Go
package main

import (
	"github.com/deckarep/gosx-notifier"
	"net/http"
	"strings"
	"time"
)

//a slice of string sites that you are interested in watching
var sites []string = []string{
	"http://www.yahoo.com",
	"http://www.google.com",
	"http://www.bing.com"}

func main() {
	ch := make(chan string)

	for _, s := range sites {
		go pinger(ch, s)
	}

	for {
		select {
		case result := <-ch:
			if strings.HasPrefix(result, "-") {
				s := strings.Trim(result, "-")
				showNotification("Urgent, can't ping website: " + s)
			}
		}
	}
}

func showNotification(message string) {

	note := gosxnotifier.NewNotification(message)
	note.Title = "Site Down"
	note.Sound = gosxnotifier.Default

	note.Push()
}

//Prefixing a site with a + means it's up, while - means it's down
func pinger(ch chan string, site string) {
	for {
		res, err := http.Get(site)

		if err != nil {
			ch <- "-" + site
		} else {
			if res.StatusCode != 200 {
				ch <- "-" + site
			} else {
				ch <- "+" + site
			}
			res.Body.Close()
		}
		time.Sleep(30 * time.Second)
	}
}
```

Usage Ideas
-----------
* Monitor your awesome server cluster and push notifications when something goes haywire (we've all been there)
* Scrape Hacker News looking for articles of certain keywords and push a notification
* Monitor your stock performance, push a notification, before you lose all your money
* Hook it up to ifttt.com and push a notification when your motion-sensor at home goes off

Coming Soon
-----------
* Remove ID

Licence
-------
This project is dual licensed under [any licensing defined by the underlying apps](https://github.com/alloy/terminal-notifier) and MIT licensed for this version written in Go.


[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/deckarep/gosx-notifier/trend.png)](https://bitdeli.com/free "Bitdeli Badge")


gosx-notifier

OSX library to notify about any (pluggable) activity on your machine

# Activity tracker

[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go) [![codecov](https://codecov.io/gh/prashantgupta24/activity-tracker/branch/master/graph/badge.svg)](https://codecov.io/gh/prashantgupta24/activity-tracker) [![Go Report Card](https://goreportcard.com/badge/github.com/prashantgupta24/activity-tracker)](https://goreportcard.com/report/github.com/prashantgupta24/activity-tracker) [![version][version-badge]][RELEASES]

It is a libary that lets you monitor certain activities on your machine, and then sends a [heartbeat](https://github.com/prashantgupta24/activity-tracker#heartbeat-struct) at a periodic (configurable) time detailing all the activity changes during that time. The activities that you want to track are monitored by **pluggable** handlers for those activities and can be added or removed according to your needs. An example of an activity is `MouseCursorActivity`, i.e. whether your mouse cursor was moved or not.

## Installation

` go get -u github.com/prashantgupta24/activity-tracker`

## Usage

```go
heartbeatInterval := 60 //value always in seconds
workerInterval := 5     //seconds

activityTracker := &tracker.Instance{
	HeartbeatInterval: heartbeatInterval,
	WorkerInterval:    workerInterval,
	LogLevel:          logging.Info,
}

//This starts the tracker for all handlers currently implemented. It gives you a channel on
//which you can listen to for heartbeat objects
heartbeatCh := activityTracker.Start()

//if you only want to track certain handlers, you can use StartWithhandlers
//heartbeatCh := activityTracker.StartWithHandlers(handler.MouseClickHandler(), handler.MouseCursorHandler())


select {
case heartbeat := <-heartbeatCh:
	if !heartbeat.WasAnyActivity {
		logger.Infof("no activity detected in the last %v seconds", int(heartbeatInterval))
	} else {
		logger.Infof("activity detected in the last %v seconds.", int(heartbeatInterval))
		logger.Infof("Activity type:\n")
		for activityType, times := range heartbeat.ActivityMap {
			logger.Infof("activityType : %v times: %v\n", activityType, len(times))
		}
	}
}
```

## Output

The above code created a tracker with all (`Mouse-click`, `Mouse-movement`, `screen-change` and `machine-sleep`) handlers activated. The `heartbeat Interval` is set to 60 seconds, i.e. every 60 seconds I received a `heartbeat` which mentioned all activities that were captured.

```sh
INFO[2019-03-30T15:52:01-07:00] starting activity tracker with 60s heartbeat and 5s worker Interval... 

INFO[2019-03-30T15:53:01-07:00] activity detected in the last 60 seconds.    

INFO[2019-03-30T15:53:01-07:00] Activity type:                               
INFO[2019-03-30T15:53:01-07:00] activityType : mouse-click times: 10         
INFO[2019-03-30T15:53:01-07:00] activityType : cursor-move times: 12
INFO[2019-03-30T15:53:01-07:00] activityType : screen-change times: 7
INFO[2019-03-30T15:53:01-07:00] activityType : machine-sleep times: 1
INFO[2019-03-30T15:53:01-07:00] activityType : machine-wake times: 1
```

## How it works

There are 2 primary configs required for the tracker to work:

- `HeartbeatInterval ` 

> The Interval at which you want the heartbeat (in seconds, default 60s)


- `WorkerInterval` 

> The Interval at which you want the checks to happen within a heartbeat (default 60s).

The activity tracker gives you a [heartbeat](https://github.com/prashantgupta24/activity-tracker#heartbeat-struct) object every 60 seconds, that is based on the `HeartbeatInterval`. But there is something else to understand here. In order for the tracker to know how many times an activity occured, like how many times you moved the cursor for example, it needs to query the mouse position every `x` seconds. That's where the `WorkerInterval` comes into play.

The `WorkerInterval` tells the tracker how frequently to check for an activity within a heartbeat. It does that by querying the handler associated with that activity. Let's say you want to know how many times the mouse cursor was moved within 60 seconds. You need to constantly ask the `mouseCursorHandler` every `x` seconds to see if the cursor moved. What you want to do is to start the tracker with the usual 60s `HeartbeatInterval `, configured with a `Mouse-cursor` handler. In this case, you set the `WorkerInterval` to 5 seconds. The tracker will then keep asking the mouse cursor handler every 5 seconds to see if there was a movement, and keep track each time there was a change. At the end of `HeartbeatInterval`, it will construct the `heartbeat` with all the changes and send it.

For example, in the output that you saw above, it says `cursor-move times: 12`. That doesn't mean the cursor was moved only 12 times. Since the `WorkerInterval` was 5 seconds in the example, that means `cursorHandler` was asked every 5 seconds (i.e. 12 times in 60 seconds) whether the cursor moved. And it replied that the cursor had indeed moved everytime. 

**Note :** This is applicable only to [pull-based handlers](https://github.com/prashantgupta24/activity-tracker#types-of-handlers). For push-based handlers, `WorkerInterval` does not matter.

- If you want to know how many `times` an activity occured within a heartbeat, you might want to set the `WorkerInterval` to a low value, so that it keeps quering the handlers.

- If you are just concerned whether any activity happened within a heartbeat or not, you can set `WorkerInterval` to a high number (something around 10-15 seconds should do the trick). That way, the workers need not be bothered a lot of times within a `heartbeat`.


> Note: If the `WorkerInterval` and the `HeartbeatInterval` are set the same, then the `WorkerInterval` always is started a fraction of a second before the `HeartbeatInterval` kicks in. This is done so that when the `heartbeat` is going to be generated at the end of `HeartbeatInterval`, the worker should have done its job of querying each of the handlers before that. 

## Usecase

Suppose you want to track Activities A, B and C on your machine, and you want to know how many times they occured every minute. 

You want a report at the end of every minute saying `Activity A` happened 5 times, `Activity B` happened 3 times and `Activity C` happened 2 times.

First, you need to create a `Handler` for each of those activities. See sections below on how to create one. The main `tracker` object will simply ask each of the handlers every `WorkerInterval` amout of time whether that activity happened or not at that moment.

As another example, let's say you want to monitor whether there was any mouse click on your machine and you want to be notified every 5 minutes. What you do is start the `Activity Tracker` with just the `mouse click` handler and `heartbeat` Interval set to 5 minutes. The `Start` function of the library gives you a channel which receives a `heartbeat` every 5 minutes, and it has details on whether there was a `click` in those 5 minutes, and if yes, the times the click happened.


# Components

### Heartbeat struct

It is the data packet sent from the tracker library to the user.

```go
type Heartbeat struct {
	WasAnyActivity bool
	ActivityMap    map[activity.Type][]time.Time //activity type with its times
	Time           time.Time                     //heartbeat time
}
```

`WasAnyActivity` tells if there was any activity within that time frame
If there was, then the `ActivityMap` will tell you what type of activity it was and what all times it occured.

The `Time` field is the time of the Heartbeat sent (not to be confused with
the activity time, which is the time the activity occured within the `heartbeat`). 

### Tracker

The tracker is the main struct for the library. The fields inside it are:

```go
HeartbeatInterval int //the interval at which you want the heartbeat (in seconds, default 60s)
WorkerInterval    int //the interval at which you want the checks to happen within a heartbeat (in seconds, default 5s)
LogLevel          string //info or debug
LogFormat         string //text or json
```

#### - `HeartbeatInterval` 

The Interval at which you want the heartbeat (in seconds, default 60s)

> The `HeartbeatInterval ` value can be set anywhere between 60 seconds - 300 seconds. Not setting it or setting it to anything other than the allowed range will revert it to default of 60s.

#### - `WorkerInterval` 

The Interval at which you want the checks to happen within a heartbeat (default 60s).

> The `WorkerInterval ` value can be set anywhere between 4 seconds - 60 seconds. It CANNOT be more than `HeartbeatInterval` for obvious reasons. Not setting it or setting it to anything other than the allowed range will revert it to default of 60s.

### State

The `system.State` struct captures the current state of the tracker, and the whole system in general. It is used by some of the handlers to respond to a certain system state. 

It is passed to the handlers when performing the Trigger, so that the handlers can take an informed decision on whether to get activated or not at that instance.

For example, the `sleepHandler` changes the state of the system to sleeping, so that the `mouseCursorHandler` and `mouseClickHandler` don't need to do any work while the system remains in the sleep state.

> Note: It also serves as a way of inter-handler communication.

## Types of handlers

There are 2 types of handlers:

- Push based
- Pull based


The `push` based ones are those that automatically push to the `tracker` object when an activity happened. Examples are the `mouseClickHander` and `machineSleepHandler`. Whenever a mouse-click/machine-sleep happens, it sends the `activity` to the `tracker` object.

The `pull` based ones are those that the `tracker` has to ask the handler to know if there was any activity happening at that moment.
Examples are `mouseCursorHandler` and `screenChangeHandler`. The `asking` is done through the `Trigger` function implemented by handlers.

It is up to you to define how to implement the handler. Some make sense to be pull based, since it is going to be memory intensive to make the mouse cursor movement handler push-based. It made sense to make it `pull` based.

## New pluggable handlers for activities

```go
//Handler interface
Start(*log.Logger, chan *activity.Instance)
Type() activity.Type
Trigger(system.State) //used to activate pull-based handlers
Close()
```
	
Any new type of handler for an activity can be easily added, it just needs to implement the above `Handler` interface and define what `type` of activity it is going to track (also add the new `activity` as well if it's a new activity), that's it! It can be plugged in with the tracker and then the tracker will include those activity checks in its heartbeat.

> Note: Handlers have a one-to-many relationship with activity, i.e. each Handler can be associated with one or more activity (That becomes the value returned by handler's `Type`) On the other hand, each activity should be tracked by only ONE handler (which makes sense).
> As a fail-safe, if the tracker is started with more than one handler tracking the same activity, then only 1 handler will get registered for that activity.

## Currently supported list of activities/handlers


### Activities

```go
MouseCursorMovement Type = "cursor-move"
MouseClick          Type = "mouse-click"
ScreenChange        Type = "screen-change"
MachineSleep        Type = "machine-sleep"
MachineWake         Type = "machine-wake"
```

### Corresponding handlers

```go
mouseCursorHandler
mouseClickHandler
screenChangeHandler
machineSleepHandler
```
	
- Mouse click (whether any mouse click happened during the time frame)
- Mouse cursor movement (whether the mouse cursor was moved during the time frame)
- Screen change handler (whether the active window was changed)
- Machine sleep/wake handler (**this is added by default for fail-safe measures**)

Thanks to [robotgo](https://github.com/go-vgo/robotgo) for making a lot of the handlers possible.

## Example

Check out the example [here](https://github.com/prashantgupta24/activity-tracker/blob/master/example/example.go)

## Projects using this library

- [automatic-mouse-mover](https://github.com/prashantgupta24/automatic-mouse-mover): a minimalistic go library/app to prevent your mac from going to sleep


[version-badge]: https://img.shields.io/github/release/prashantgupta24/activity-tracker.svg
[RELEASES]: https://github.com/prashantgupta24/activity-tracker/releases


mac-activity-tracker

Go Native cross-platform GUI system automation. Control the mouse, keyboard and other

# Robotgo




[![Build Status](https://github.com/go-vgo/robotgo/workflows/Go/badge.svg)](https://github.com/go-vgo/robotgo/commits/master)
[![CircleCI Status](https://circleci.com/gh/go-vgo/robotgo.svg?style=shield)](https://circleci.com/gh/go-vgo/robotgo)
[![Go Report Card](https://goreportcard.com/badge/github.com/go-vgo/robotgo)](https://goreportcard.com/report/github.com/go-vgo/robotgo)
[![GoDoc](https://pkg.go.dev/badge/github.com/go-vgo/robotgo?status.svg)](https://pkg.go.dev/github.com/go-vgo/robotgo?tab=doc)
[![GitHub release](https://img.shields.io/github/release/go-vgo/robotgo.svg)](https://github.com/go-vgo/robotgo/releases/latest)

> Golang Desktop Automation, auto test and AI Computer Use. <br>
> Control the mouse, keyboard, read the screen, process, Window Handle, image and bitmap and global event listener.

RobotGo supports Mac, Windows, and Linux (X11); and robotgo supports arm64 and x86-amd64.

[RobotGo-Pro](https://github.com/vcaesar/robotgo-pro) get the JavaScript, Python, Lua and others version, tech supports, new features and newest robotgo version (such as Wayland support, "no open-source version now").

## Contents

- [Docs](#docs)
- [Binding](#binding)
- [Requirements](#requirements)
- [Installation](#installation)
- [Update](#update)
- [Examples](#examples)
- [Type Conversion and keys](https://github.com/go-vgo/robotgo/blob/master/docs/keys.md)
- [Cross-Compiling](https://github.com/go-vgo/robotgo/blob/master/docs/install.md#crosscompiling)
- [Authors](#authors)
- [Plans](#plans)
- [License](#license)

## Docs

- [GoDoc](https://godoc.org/github.com/go-vgo/robotgo) <br>
- [API Docs](https://github.com/go-vgo/robotgo/blob/master/docs/doc.md) (Deprecated, no updated)

## Binding:

[ADB](https://github.com/vcaesar/adb), packaging android adb API.

## Requirements:

Now, Please make sure `Golang, GCC` is installed correctly before installing RobotGo.

### ALL:

```
Golang

GCC
```

#### For MacOS:

```
brew install go
```

Xcode Command Line Tools; <br>
And Privacy setting, add Screen Recording and Accessibility under: <br>
`System Settings > Privacy & Security > Accessibility, Screen & System Audio Recording`.

```
xcode-select --install
```

#### For Windows:

```
winget install Golang.go
```

[llvm-mingw](https://github.com/mstorsjo/llvm-mingw)

```
winget install MartinStorsjo.LLVM-MinGW.UCRT
```

or [Mingw-w64](https://sourceforge.net/projects/mingw-w64/files)

```
winget install BrechtSanders.WinLibs.POSIX.UCRT
```

Or Download the [Mingw-w64](https://sourceforge.net/projects/mingw-w64/files) and the others gcc, then set system environment variables like `C:\mingw64\bin` to the env `Path`.
[Set environment variables to run GCC from command line](https://www.youtube.com/results?search_query=Set+environment+variables+to+run+GCC+from+command+line).

`Or The others GCC` (Except the Mingw-w64, you should compile the "libpng" with yourself when use the [bitmap](https://github.com/vcaesar/bitmap).)

#### For everything else:

```
GCC

X11 with the XTest extension (the Xtst library)

"Clipboard": xsel xclip

"Bitmap": libpng (Just used by the "bitmap".)

"Event-Gohook": xcb, xkb, libxkbcommon (Just used by the "hook".)
```

##### Ubuntu:

```yml
# sudo apt install golang
sudo snap install go  --classic

# gcc
sudo apt install gcc libc6-dev

# x11
sudo apt install libx11-dev xorg-dev libxtst-dev

# Clipboard
sudo apt install xsel xclip

# Bitmap
sudo apt install libpng++-dev

# GoHook
sudo apt install xcb libxcb-xkb-dev x11-xkb-utils libx11-xcb-dev libxkbcommon-x11-dev libxkbcommon-dev
```

##### Fedora:

```yml
# x11
sudo dnf install libXtst-devel

# Clipboard
sudo dnf install xsel xclip

# Bitmap
sudo dnf install libpng-devel

# GoHook
sudo dnf install libxkbcommon-devel libxkbcommon-x11-devel xorg-x11-xkb-utils-devel
```

## Installation:

With Go module support (Go 1.11+), just import:

```go
import "github.com/go-vgo/robotgo"
```

Otherwise, to install the robotgo package, run the command:

```
go get github.com/go-vgo/robotgo
```

png.h: No such file or directory? Please see [issues/47](https://github.com/go-vgo/robotgo/issues/47).

## Update:

```
go get -u github.com/go-vgo/robotgo
```

Note go1.10.x C file compilation cache problem, [golang #24355](https://github.com/golang/go/issues/24355).
`go mod vendor` problem, [golang #26366](https://github.com/golang/go/issues/26366).

## [Examples:](https://github.com/go-vgo/robotgo/blob/master/examples)

#### [Mouse](https://github.com/go-vgo/robotgo/blob/master/examples/mouse/main.go)

```Go
package main

import (
  "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")
}
```

#### [Keyboard](https://github.com/go-vgo/robotgo/blob/master/examples/key/main.go)

```Go
package main

import (
  "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)
  }
}
```

#### [Screen](https://github.com/go-vgo/robotgo/blob/master/examples/screen/main.go)

```Go
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](https://github.com/vcaesar/bitmap/blob/main/examples/main.go)

```Go
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](https://github.com/vcaesar/gcv)

```Go
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](https://github.com/robotn/gohook/blob/master/examples/main.go)

```Go
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](https://github.com/go-vgo/robotgo/blob/master/examples/window/main.go)

```Go
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](https://github.com/vcaesar)
- [Maintainers](https://github.com/orgs/go-vgo/people)

## Plans

- Refactor some C code to Go (such as x11, windows)
- Better multiscreen support
- Wayland support
- Update Window Handle
- Try to support Android and IOS

## Contributors

- See [contributors page](https://github.com/go-vgo/robotgo/graphs/contributors) for full list of contributors.
- See [Contribution Guidelines](https://github.com/go-vgo/robotgo/blob/master/CONTRIBUTING.md).

## 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](http://www.apache.org/licenses/LICENSE-2.0), [LICENSE](https://github.com/go-vgo/robotgo/blob/master/LICENSE).

robotgo

<img alt="DarwinKit Logo" src="https://github.com/progrium/darwinkit/raw/main/darwinkit.png" style="height:125px;" />

Native Apple APIs for Golang!




[![GoDoc](https://godoc.org/github.com/progrium/darwinkit?status.svg)](https://pkg.go.dev/github.com/progrium/darwinkit@main)
[![Go Report Card](https://goreportcard.com/badge/github.com/progrium/darwinkit)](https://goreportcard.com/report/github.com/progrium/darwinkit)
<a href="https://twitter.com/progrium" title="@progrium on Twitter"><img src="https://img.shields.io/badge/twitter-@progrium-55acee.svg" alt="@progrium on Twitter"></a>
<a href="https://github.com/progrium/darwinkit/discussions" title="Project Forum"><img src="https://img.shields.io/badge/community-forum-ff69b4.svg" alt="Project Forum"></a>
<a href="https://github.com/sponsors/darwinkitdev" title="Sponsor Project"><img src="https://img.shields.io/static/v1?label=sponsor&message=%E2%9D%A4&logo=GitHub" alt="Sponsor Project" /></a>

> [!IMPORTANT]
> July 11, 2024: **MacDriver is now DarwinKit!** You can also now get high-quality example starter apps when you [support the project as a sponsor](https://github.com/sponsors/darwinkitdev).

------

![ScanDrop Demo](https://github.com/progrium/darwinkit/assets/1813419/e66e4ca1-af6b-4952-9e53-f10ab436993f)
![SnowScape Demo](https://github.com/progrium/darwinkit/assets/1813419/3b04b849-4292-41c5-8563-7735ff46c745)
![MenuSpacer Demo](https://github.com/progrium/darwinkit/assets/1813419/ed86724d-f1fc-42e4-b9c9-0112fffd86fc)
![ClipTrail Demo](https://github.com/progrium/darwinkit/assets/1813419/c018851d-5af7-4cf6-8e21-213c28752438)


DarwinKit lets you work with [supported Apple frameworks](https://pkg.go.dev/github.com/progrium/darwinkit/macos@main#section-directories) and build native applications using Go. With XCode and Go 1.18+ installed, you can write this program in a `main.go` file:

```go
package main

import (
	"github.com/progrium/darwinkit/objc"
	"github.com/progrium/darwinkit/macos"
	"github.com/progrium/darwinkit/macos/appkit"
	"github.com/progrium/darwinkit/macos/foundation"
	"github.com/progrium/darwinkit/macos/webkit"
)

func main() {
	// runs macOS application event loop with a callback on success
	macos.RunApp(func(app appkit.Application, delegate *appkit.ApplicationDelegate) {
		app.SetActivationPolicy(appkit.ApplicationActivationPolicyRegular)
		app.ActivateIgnoringOtherApps(true)

		url := foundation.URL_URLWithString("https://github.com/sponsors/darwinkitdev")
		req := foundation.NewURLRequestWithURL(url)
		frame := foundation.Rect{Size: foundation.Size{1440, 900}}

		config := webkit.NewWebViewConfiguration()
		wv := webkit.NewWebViewWithFrameConfiguration(frame, config)
		wv.LoadRequest(req)

		w := appkit.NewWindowWithContentRectStyleMaskBackingDefer(frame,
			appkit.ClosableWindowMask|appkit.TitledWindowMask,
			appkit.BackingStoreBuffered, false)
		objc.Retain(&w)
		w.SetContentView(wv)
		w.MakeKeyAndOrderFront(w)
		w.Center()

		delegate.SetApplicationShouldTerminateAfterLastWindowClosed(func(appkit.Application) bool {
			return true
		})
	})
}

```

Then in this directory run:

```
go mod init helloworld
go get github.com/progrium/darwinkit@main
go run main.go
```

This may take a moment the first time, but once the window pops up you just made a macOS program without using XCode or Objective-C. Run `go build` to get an executable. 

Although currently outside the scope of this project, if you wanted you could put this executable [into an Application bundle](https://stackoverflow.com/a/3251285). You could even add [entitlements](https://developer.apple.com/documentation/bundleresources/entitlements?language=objc), then [sign and notarize](https://developer.apple.com/support/code-signing/) this bundle or executable to let others run it. It could theoretically even be put on the App Store. It could *theoretically* be put on an iOS, tvOS, or watchOS device, though you would have to use different platform specific frameworks.

### Caveats

* You still need to know or learn how Apple frameworks work, so you'll have to use Apple documentation and understand how to translate Objective-C example code to the equivalent Go with DarwinKit.
* Your programs link against the actual Apple frameworks using [cgo](https://pkg.go.dev/cmd/cgo), so XCode needs to be installed for the framework headers.
* You will be using two memory management systems. Framework objects are managed by [Objective-C memory management](https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/MemoryMgmt/Articles/MemoryMgmt.html#//apple_ref/doc/uid/10000011-SW1), so be sure to read our docs on [memory management](docs/memorymanagement.md) with DarwinKit.
* Exceptions in frameworks will segfault, giving you both an Objective-C stacktrace and a Go panic stacktrace. You will be debugging a hybrid Go and Objective-C program.
* Goroutines that interact with GUI objects need to [dispatch](https://pkg.go.dev/github.com/progrium/darwinkit@main/dispatch) operations on the main thread otherwise it will segfault.

This is all tenable for simple programs, but these are the reasons we don't *recommend* large/complex programs using DarwinKit.

## Examples

There are basic usage examples [here in this repo](./macos/_examples), but there are higher-quality full utilities you can use as examples or starter templates [when you sponsor](https://github.com/sponsors/darwinkitdev).

![LargeType Demo](https://github.com/progrium/darwinkit/assets/1813419/b54a8015-dfef-40ce-bc56-f75cb8455306)
![ScanDrop Demo](https://github.com/progrium/darwinkit/assets/1813419/e66e4ca1-af6b-4952-9e53-f10ab436993f)
![SnowScape Demo](https://github.com/progrium/darwinkit/assets/1813419/3b04b849-4292-41c5-8563-7735ff46c745)
![LiveTemp Demo](https://github.com/progrium/darwinkit/assets/1813419/c57cd196-3ff6-4068-bd0a-05b9283d199d)
![MenuSpacer Demo](https://github.com/progrium/darwinkit/assets/1813419/ed86724d-f1fc-42e4-b9c9-0112fffd86fc)
![ClipTrail Demo](https://github.com/progrium/darwinkit/assets/1813419/c018851d-5af7-4cf6-8e21-213c28752438)
![FocusTimer Demo](https://github.com/progrium/darwinkit/assets/1813419/9e14fe2f-88a9-4b89-9f9c-a305fb103d4c)


## How it works

<details>
<summary>Brief background on Objective-C</summary>
	
Ever since acquiring NeXT Computer in the 90s, Apple has used [NeXTSTEP](https://en.wikipedia.org/wiki/NeXTSTEP) as the basis of their software stack, which is written in Objective-C. Unlike most systems languages with object orientation, Objective-C implements OOP as a runtime library. In fact, Objective-C is just C with the weird OOP specific syntax rewritten into C calls to [libobjc](https://developer.apple.com/documentation/objectivec/objective-c_runtime?language=objc), which is a normal C library implementing an object runtime. This runtime could be used to bring OOP to any language that can make calls to C code. It also lets you interact with objects and classes registered by other libraries, such as the Apple frameworks. 

</details>

At the heart of DarwinKit is a package wrapping the Objective-C runtime using [cgo](https://pkg.go.dev/cmd/cgo) and [libffi](https://github.com/libffi/libffi). This is actually all you need to interact with Objective-C objects and classes, it'll just look like this:

```go
app := objc.Call[objc.Object](objc.GetClass("NSApplication"), objc.Sel("sharedApplication"))
objc.Call[objc.Void](app, objc.Sel("run"))
```

So we wrap these calls in a [Go API](docs/bindings.md) that lets us write code like this:

```go
app := appkit.Application_SharedApplication()
app.Run()
```

These bindings are great, but we need to define them for every API we want to use. Presently,
Apple has around 200 frameworks of nearly 5000 classes with 77k combined methods and properties. Not to 
mention all the constants, functions, structs, unions, and enums we need to work with those objects.

So DarwinKit generates its bindings. This is the hard part. Making sure the generation pipeline accurately produces usable bindings for all possible symbols is quite an arduous, iterative, manual process. Then since we're moving symbols that lived in a single namespace into Go packages, we have to manually decouple dependencies between them enough to avoid circular imports. If you want to help add frameworks, read our documentation on [generation](docs/generation.md).

Objects are passed around as typed pointer values in Objective-C. When we receive an object from a method
call in Go, the `objc` package receives it as a raw pointer, which it first puts into an `unsafe.Pointer`. The
bindings for a class define a struct type that embeds an `objc.Object` struct, which contains a single
field to hold the `unsafe.Pointer`. So unless working with a primitive type, you're working with an `unsafe.Pointer` wrapped in an `objc.Object` wrapped in a struct type that has the methods for the class of the object of the pointer. Be sure to read our documentation on [memory management](docs/memorymanagement.md).

If you have questions, feel free to ask in the [discussion forums](https://github.com/progrium/darwinkit/discussions).

## Thanks

This project was inspired by and originally based on packages written by [Mikkel Krautz](https://github.com/mkrautz). The latest version is based on packages written by [Dong Liu](https://github.com/hsiafan).

## Notice

This project is not affiliated or supported by Apple.

## License

MIT


DarwinKit

A framework for building 2D and 3D apps that run on macOS, Windows, Linux, iOS, Android, and the web

<h1 align="center">
    <a href="https://cogentcore.org/core">
        <img alt="Cogent Core Logo" src="icon.svg"><br>
        <img alt="Cogent Core Name Banner" width="612" src="docs/name.png">
    </a>
</h1>

<p align="center">
    <a href="https://goreportcard.com/report/cogentcore.org/core"><img src="https://goreportcard.com/badge/cogentcore.org/core" alt="Go Report Card"></a>
    <a href="https://pkg.go.dev/cogentcore.org/core"><img src="https://img.shields.io/badge/dev-reference-007d9c?logo=go&logoColor=white&style=flat" alt="pkg.go.dev docs"></a>
    <a href="https://github.com/cogentcore/core/actions"><img alt="GitHub Actions Workflow Status" src="https://img.shields.io/github/actions/workflow/status/cogentcore/core/go.yml"></a>
    <a href="https://raw.githack.com/wiki/cogentcore/core/coverage.html"><img alt="Test Coverage" src="https://github.com/cogentcore/core/wiki/coverage.svg"></a>
    <a href="https://github.com/cogentcore/core/tags"><img alt="Version" src="https://img.shields.io/github/v/tag/cogentcore/core?label=version&color=blue"></a>
</p>

Cogent Core is a free and open source framework for building powerful, fast, elegant 2D and 3D apps that run on macOS, Windows, Linux, iOS, Android, and web with a single Go codebase, allowing you to Code Once, Run Everywhere (Core). See the [Cogent Core Website](https://cogentcore.org/core) for more information, including extensive documentation and interactive examples you can directly edit and run. The website itself is a Cogent Core app running on the web using wasm. You must complete the install instructions on the website before developing with Cogent Core on your system.

## Sponsors

We thank our [sponsors](https://github.com/sponsors/cogentcore) for their support, which allows us to spend more time improving Cogent Core.


Cogent Core

Go bindings for Sciter: the Embeddable HTML/CSS/script engine for modern desktop UI development. Cross platform

# Go bindings for Sciter

[![AppVeyor status](https://ci.appveyor.com/api/projects/status/rphv883klffw9em9/branch/master?svg=true)](https://ci.appveyor.com/project/pravic/go-sciter)
[![Travis Status](https://travis-ci.com/sciter-sdk/go-sciter.svg?branch=master)](https://travis-ci.com/sciter-sdk/go-sciter)
[![License](https://img.shields.io/github/license/sciter-sdk/go-sciter.svg)](https://github.com/sciter-sdk/go-sciter)
[![Join the forums at https://sciter.com/forums](https://img.shields.io/badge/forum-sciter.com-orange.svg)](https://sciter.com/forums)

Check [this page](http://sciter.com/developers/sciter-sdk-bindings/) for other language bindings (Delphi / D / Go / .NET / Python / Rust).

----


# Attention

The ownership of project is transferred to this new organization.
Thus the `import path` for golang should now be `github.com/sciter-sdk/go-sciter`, but the package name is still `sciter`.

# Introduction

This package provides a Golang bindings of [Sciter][] using cgo.
Using go sciter you must have the platform specified `sciter dynamic library`
downloaded from [sciter-sdk][], the library itself is rather small
 (under 5MB, less than 2MB when upxed) .

Most [Sciter][] API are supported, including:

 * Html string/file loading
 * DOM manipulation/callback/event handling
 * DOM state/attribute handling
 * Custom resource loading
 * Sciter Behavior
 * Sciter Options
 * Sciter Value support
 * NativeFunctor (used in sciter scripting)

And the API are organized in more or less a gopher friendly way.

Things that are not supported:

 * Sciter Node API
 * TIScript Engine API

# Getting Started

###  At the moment only **Go 1.10** or higher is supported (issue #136).

 1. Download the [sciter-sdk][]
 2. Extract the sciter runtime library from [sciter-sdk][] to system PATH

    The runtime libraries lives in `bin` `bin.lnx` `bin.osx` with suffix like `dll` `so` or `dylib`

    * Windows: simply copying `bin\64\sciter.dll` to `c:\windows\system32` is just enough
    * Linux:
      - `cd sciter-sdk/bin.lnx/x64`
      - `export LIBRARY_PATH=$PWD`
      - `echo $PWD >> libsciter.conf`
      - `sudo cp libsciter.conf /etc/ld.so.conf.d/`
      - `sudo ldconfig`
      - `ldconfig -p | grep sciter` should print libsciter-gtk.so location
    * OSX:
      - `cd sciter-sdk/bin.osx/`
      - `export DYLD_LIBRARY_PATH=$PWD`

 3. Set up GCC envrionmnet for CGO

    [mingw64-gcc][] (5.2.0 and 7.2.0 are tested) is recommended for Windows users.

    Under Linux gcc(4.8 or above) and gtk+-3.0 are needed.

 4. `go get -x github.com/sciter-sdk/go-sciter`

 5. Run the example and enjoy :)

# Sciter Desktop UI Examples

![](http://sciter.com/screenshots/slide-wt5.png)

![](http://sciter.com/screenshots/slide-norton360.png)

![](http://sciter.com/screenshots/slide-norton-nis.png)

![](http://sciter.com/screenshots/slide-cardio.png)

![](http://sciter.com/screenshots/slide-surveillance.png)

![](http://sciter.com/screenshots/slide-technology.png)

![](http://sciter.com/screenshots/slide-sciter-ide.png)

![](http://sciter.com/screenshots/slide-sciter-osx.png)

![](http://sciter.com/screenshots/slide-sciter-gtk.png)


# Sciter Version Support
Currently supports [Sciter][] version `4.0.0.0` and higher.

[Sciter]: http://sciter.com/
[sciter-sdk]: http://sciter.com/download/

# About Sciter

[Sciter][] is an `Embeddable HTML/CSS/script engine for modern UI development, Web designers, and developers, can reuse their experience and expertise in creating modern looking desktop applications.`

In my opinion, [Sciter][] , though not open sourced, is an great
desktop UI development envrionment using the full stack of web technologies,
which is rather small (under 5MB) especially compared to [CEF][],[Node Webkit][nw] and [Atom Electron][electron]. :)

Finally, according to [Andrew Fedoniouk][author] the author and the Sciter
`END USER LICENSE AGREEMENT` , the binary form of the [Sciter][]
dynamic libraries are totally free to use for commercial or
non-commercial applications.

# The Tailored Sciter C Headers
This binding ueses a tailored version of the sciter C Headers, which lives in directory: `include`. The included c headers are a modified version of the
[sciter-sdk][] standard headers.

It seems [Sciter][] is developed using C++, and the included headers in the
[Sciter SDK][sciter-sdk] are a mixture of C and C++, which is not
quite suitable for an easy golang binding.

I'm not much fond of C++ since I started to use Golang, so I made this
modification and hope [Andrew Fedoniouk][author] the author would provide
pure C header files for Sciter. :)

[CEF]:https://bitbucket.org/chromiumembedded/cef
[nw]: https://github.com/nwjs/nw.js
[electron]:https://github.com/atom/electron

[author]: http://sciter.com/about/
[mingw64-gcc]: http://sourceforge.net/projects/mingw-w64/


go-sciter

Cross platform Go library to place an icon and menu in the notification area

# systray

systray is a cross-platform Go library to place an icon and menu in the notification area.

## Features

* Supported on Windows, macOS, and Linux
* Menu items can be checked and/or disabled
* Most functions may be called from any goroutine

## API

```go
func main() {
	systray.Run(onReady, onExit)
}

func onReady() {
	systray.SetIcon(icon.Data)
	systray.SetTitle("Awesome App")
	systray.SetTooltip("Pretty awesome超级棒")
	mQuit := systray.AddMenuItem("Quit", "Quit the whole app")

	// Sets the icon of a menu item. Only available on Mac and Windows.
	mQuit.SetIcon(icon.Data)
}

func onExit() {
	// clean up here
}
```

See [![full API](https://pkg.go.dev/badge/github.com/getlantern/systray.svg)](https://pkg.go.dev/github.com/getlantern/systray) as well as [CHANGELOG](https://github.com/getlantern/systray/tree/master/CHANGELOG.md).

Note: this package requires cgo, so make sure you set `CGO_ENABLED=1` before building.

## Try the example app!

Have go v1.12+ or higher installed? Here's an example to get started on macOS:

```sh
git clone https://github.com/getlantern/systray
cd systray/example
env GO111MODULE=on go build
./example
```

On Windows, you should build like this:

```
env GO111MODULE=on go build -ldflags "-H=windowsgui"
```

Now look for *Awesome App* in your menu bar!

![Awesome App screenshot](example/screenshot.png)

## The Webview example

The code under `webview_example` is to demostrate how it can co-exist with other UI elements. Note that the example doesn't work on macOS versions older than 10.15 Catalina.

## Platform notes

### Linux

* Building apps requires gcc as well as the `gtk3` and `libayatana-appindicator3` development headers to be installed. For Debian or Ubuntu, you may install these using:

```sh
sudo apt-get install gcc libgtk-3-dev libayatana-appindicator3-dev
```

On Linux Mint, `libxapp-dev` is also required.

If you need to support the older `libappindicator3` library instead, you can pass the build flag `legacy_appindicator`
when building. For example:

```
go build -tags=legacy_appindicator
```

To build `webview_example`, you also need to install `libwebkit2gtk-4.0-dev` and remove `webview_example/rsrc.syso` which is required on Windows.

### Windows

* To avoid opening a console at application startup, use these compile flags:

```sh
go build -ldflags -H=windowsgui
```

### macOS

On macOS, you will need to create an application bundle to wrap the binary; simply folders with the following minimal structure and assets:

```
SystrayApp.app/
  Contents/
    Info.plist
    MacOS/
      go-executable
    Resources/
      SystrayApp.icns
```

When running as an app bundle, you may want to add one or both of the following to your Info.plist:

```xml

	<key>NSHighResolutionCapable</key>
	<string>True</string>

	
	<key>LSUIElement</key>
	<string>1</string>
```

Consult the [Official Apple Documentation here](https://developer.apple.com/library/archive/documentation/CoreFoundation/Conceptual/CFBundles/BundleTypes/BundleTypes.html#//apple_ref/doc/uid/10000123i-CH101-SW1).

On macOS, it's possible to set the underlying
[`NSStatusItemBehavior`](https://developer.apple.com/documentation/appkit/nsstatusitembehavior?language=objc)
with `systray.SetRemovalAllowed(true)`. When enabled, the user can cmd-drag the
icon off the menu bar.

## Credits

- https://github.com/xilp/systray
- https://github.com/cratonica/trayhost

systray

Cross-platform Go library and CLI to create simple dialogs that interact graphically with the user

# Zenity dialogs for Golang, Windows and macOS

[![Go Reference](https://pkg.go.dev/badge/image)](https://pkg.go.dev/github.com/ncruces/zenity)
[![Go Report](https://goreportcard.com/badge/github.com/ncruces/zenity)](https://goreportcard.com/report/github.com/ncruces/zenity)
[![Go Coverage](https://github.com/ncruces/zenity/wiki/coverage.svg)](https://raw.githack.com/wiki/ncruces/zenity/coverage.html)
[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go)

This repo includes:
- a cross-platform [Go](https://go.dev/) package providing
[Zenity](https://gitlab.gnome.org/GNOME/zenity)-like dialogs
(simple dialogs that interact graphically with the user)
- a *“port”* of the `zenity` command to both Windows and macOS based on that library.

Implemented dialogs:
* [message](https://github.com/ncruces/zenity/wiki/Message-dialog) (error, info, question, warning)
* [text entry](https://github.com/ncruces/zenity/wiki/Text-entry-dialog)
* [list](https://github.com/ncruces/zenity/wiki/List-dialog) (simple)
* [password](https://github.com/ncruces/zenity/wiki/Password-dialog)
* [file selection](https://github.com/ncruces/zenity/wiki/File-selection-dialog)
* [color selection](https://github.com/ncruces/zenity/wiki/Color-selection-dialog)
* [calendar](https://github.com/ncruces/zenity/wiki/Calendar-dialog)
* [progress](https://github.com/ncruces/zenity/wiki/Progress-dialog)
* [notification](https://github.com/ncruces/zenity/wiki/Notification)

Behavior on Windows, macOS and other Unixes might differ slightly.
Some of that is intended (reflecting platform differences),
other bits are unfortunate limitations.

## Installing

The Go package:

    go get github.com/ncruces/zenity@latest

The `zenity` command on macOS/WSL using [Homebrew](https://brew.sh/) 🍺:

    brew install ncruces/tap/zenity

The `zenity` command on Windows using [Scoop](https://scoop.sh/) 🍨:

    scoop install https://ncruces.github.io/scoop/zenity.json

The `zenity` command on macOS/Windows, if you have [Go](https://go.dev/):

    go install github.com/ncruces/zenity/cmd/zenity@latest

Or download the [latest release](https://github.com/ncruces/zenity/releases/latest).

## Using

For the Go package, consult the [documentation](https://pkg.go.dev/github.com/ncruces/zenity#section-documentation)
and [examples](https://pkg.go.dev/github.com/ncruces/zenity#pkg-examples).

The `zenity` command does its best to be compatible with the GNOME version.\
Consult the [documentation](https://gitlab.gnome.org/GNOME/zenity)
and [man page](https://linux.die.net/man/1/zenity) of that command.

## Why?

#### Benefits of the Go package:

* no `cgo` (see [benefits](https://dave.cheney.net/2016/01/18/cgo-is-not-go), mostly cross-compilation)
* no main loop (or any other threading or initialization requirements)
* cancelation through [`context`](https://golang.org/pkg/context/)
* on Windows:
  * no additional dependencies
    * Explorer shell not required
    * works in Server Core
  * Unicode support
  * High DPI (no manifest required)
  * Visual Styles (no manifest required)
  * WSL/Cygwin/MSYS2 [support](https://github.com/ncruces/zenity/wiki/Zenity-for-WSL,-Cygwin,-MSYS2)
* on macOS:
  * only dependency is `osascript`
* on other Unixes:
  * wraps either one of `zenity`, `matedialog`, [`qarma`](https://github.com/luebking/qarma)

## Zenity wrappers

Zenity wrappers for languages other than Go can benefit from our `zenity` command. On Unix (Linux, FreeBSD, etc) they can use the original tool, and on Windows/macOS they may use the command from this repo for portability.

Examples:
- NodeJS [`dialog-gui`](https://github.com/SnurfDev/dialog-gui) by [@SnurfDev](https://github.com/SnurfDev/dialog-gui)
- Crystal [`zenity.cr`](https://github.com/kojix2/zenity.cr) by [@kojix2](https://github.com/kojix2/)

## Credits

I'd like to thank all [contributors](https://github.com/ncruces/zenity/graphs/contributors),
but [@gen2brain](https://github.com/gen2brain) in particular
for [`dlgs`](https://github.com/gen2brain/dlgs),
which was instrumental to the Windows port of `zenity`.


zenity

[![Go Reference](https://pkg.go.dev/badge/github.com/goradd/html5tag.svg)](https://pkg.go.dev/github.com/goradd/html5tag)
![Build Status](https://img.shields.io/github/workflow/status/goradd/html5tag/Go)
[![Go Report Card](https://goreportcard.com/badge/github.com/goradd/html5tag)](https://goreportcard.com/report/github.com/goradd/html5tag)
[![codecov](https://codecov.io/gh/goradd/html5tag/branch/main/graph/badge.svg?token=L8KC75KWWR)](https://codecov.io/gh/goradd/html5tag)

# html5tag

The html5tag package contains utilities to generate html 5 tags. 
Choose between string versions of the
functions for easy tag creation, or io.Writer versions for speed.

html5tag also has a tag builder for convenience and can perform math operations
on numeric style values.

html5tag does some checks to make sure tags are well-formed. For example,
when adding data-* attributes, it will make sure the key used for the
attribute does not violate html syntax rules.

html5tag has options to pretty-print tags and the content of tags so they appear formatted
in a document. However, in certain contexts, like in inline text, or in a textarea tag, adding
extra returns and spaces changes the look of the output. In these situations, use the functions
that do not add spaces to the inner HTML of a tag.

Some examples:

```go
package main

import . "github.com/goradd/html5tag"

main() {
	
	// Render an input tag, inside a div tag, inside a body tag using different tag building mechanisms

	a := NewAttributes().
	SetID("myText").
	Set("text", "Hi there").
	Set("placeholder", "Write here").
	SetClass("class1 class2").
	SetStyle("width":"20em")
	
	inputTag := RenderVoidTag("input", a)
	divTag := RenderTag("div", Attriubtes{"id":"inputWrapper"}, inputTag)
	
	bodyTag := NewTagBuilder().
		Tag("body").
		ID("bodyId").
		InnerHtml(divTag).
		String()
	
	fmt.Print(bodyTag)
}
```

For complete documentation, start at the documentation for `RenderTag()` and `WriteTag()` and drill down from there.


goradd/html5tag

GPU-accelerated GUI toolkit with 22 widgets, 3 design systems (Material, Fluent, Cupertino), reactive signals, and zero CGO (part of [GoGPU](https://github.com/gogpu) ecosystem)

gogpu/ui

Go bindings for libappindicator3 C library

# GopherLibs >> AppIndicator [![Go Report Card](https://goreportcard.com/badge/github.com/gopherlibs/appindicator)](https://goreportcard.com/report/github.com/gopherlibs/appindicator) [![GoDoc](https://godoc.org/github.com/gopherlibs/appindicator?status.svg)](https://godoc.org/github.com/gopherlibs/appindicator) [![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go)

Go (golang) bindings for [libayatana-appindicator3](https://github.com/AyatanaIndicators/libayatana-appindicator) C library.

Libayatana-appindicator is a library to allow applications to export a menu into the Unity Menu bar.
Based on KSNI it also works in KDE and will fallback to generic Systray support if none of those are available.

Also it works in:
 - Unity
 - GNOME Shell with [this extension](https://github.com/ubuntu/gnome-shell-extension-appindicator)
 - Budgie Desktop with [this applet](https://github.com/UbuntuBudgie/budgie-indicator-applet)
 - MATE with [this applet](https://github.com/mate-desktop/mate-indicator-applet)
 - Xfce with [this plugin](https://goodies.xfce.org/projects/panel-plugins/xfce4-indicator-plugin)

This package aims to be interoperable with [Go gtk3 bindings](https://github.com/gotk3/gotk3).

`3` in the name means that it's GTK3 version.

 ## Dependencies
 
On Debian-based distributions:

```bash
sudo apt install libayatana-appindicator3-dev libgtk-3-dev
```

And of course `go` with `cgo` is required.

## Building

Refer to [gotk3 wiki](https://github.com/gotk3/gotk3/wiki)

...or simply run [`build.sh`](./build.sh) script that will try to detect
currently installed version of GTK, pass along given `go build` flags
and execute it.

For example to build one of examples:

```bash
./build.sh -v examples/simple/main.go
```

## Examples

Examples are located in [examples](./examples) directory

## Project History

AppIndicator Go is a fork of Dawid Dziurla's [go-appindicator](https://github.com/dawidd6/go-appindicator).
That project was abanzoned and eventually archived.
This project continues where that one left off, under the same MIT license (of course).


AppIndicator Go

[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go) [![Go Report Card](https://goreportcard.com/badge/github.com/prashantgupta24/mac-sleep-notifier)](https://goreportcard.com/report/github.com/prashantgupta24/mac-sleep-notifier) [![codecov](https://codecov.io/gh/prashantgupta24/mac-sleep-notifier/branch/master/graph/badge.svg)](https://codecov.io/gh/prashantgupta24/mac-sleep-notifier) [![version][version-badge]][RELEASES] [![godoc-badge][godoc-badge]][godoc-link]

## macOS Sleep/ Wake notifications in golang

Inspired from [this](https://nicolai86.eu/blog/2017/12/sleep-wake-notifications-in-go/) blog.

This libary notifies through a channel whenever your machine is put to sleep or is woken up. Calling the `Start` function will get you a channel on which you receive both `Sleep` and `Awake` activities.

## Installation

`go get -u github.com/prashantgupta24/mac-sleep-notifier/notifier`

## Usage

```go
notifierCh := notifier.GetInstance().Start()

for {
	select {
	case activity := <-notifierCh:
		if activity.Type == notifier.Awake {
			log.Println("machine awake")
		} else {
			if activity.Type == notifier.Sleep {
				log.Println("machine sleeping")
			}
		}
	}
}
```
## Example
See example [here](https://github.com/prashantgupta24/mac-sleep-notifier/blob/master/example/example.go)

[godoc-badge]: https://img.shields.io/badge/godoc-reference-blue.svg
[godoc-link]: https://godoc.org/github.com/prashantgupta24/mac-sleep-notifier/notifier

[version-badge]: https://img.shields.io/github/release/prashantgupta24/mac-sleep-notifier.svg
[RELEASES]: https://github.com/prashantgupta24/mac-sleep-notifier/releases


mac-sleep-notifier

Cross-platform Go library to place an icon in the host operating system's taskbar

trayhost
========

[![Go Reference](https://pkg.go.dev/badge/github.com/shurcooL/trayhost.svg)](https://pkg.go.dev/github.com/shurcooL/trayhost)

Package trayhost is a cross-platform Go library to place an icon
in the host operating system's taskbar.

Platform Support
----------------

-	macOS - Fully implemented and supported by [@dmitshur](https://github.com/dmitshur).
-	Linux - Partially implemented, but unsupported (needs an owner/maintainer).
-	Windows - Partially implemented, but unsupported (needs an owner/maintainer).

Notes
-----

On macOS, for Notification Center user notifications to work, your Go binary that
uses `trayhost` must be a part of a standard macOS app bundle.

Most other functionality of `trayhost` will be available if the binary is not a part
of app bundle, but you will get a terminal pop up, and you will not be able to
configure some aspects of the app.

Here's a minimal layout of an app bundle:

```
$ tree "Trayhost Example.app"
Trayhost\ Example.app
└── Contents
    ├── Info.plist
    ├── MacOS
    │   └── example
    └── Resources
        └── Icon.icns
```

Here's a minimal `Info.plist` file as reference (only the entries that are needed,
nothing extra):

```XML
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
	<key>CFBundleExecutable</key>
	<string>example</string>
	<key>CFBundleIconFile</key>
	<string>Icon</string>
	<key>CFBundleIdentifier</key>
	<string>ExampleApp</string>
	<key>NSHighResolutionCapable</key>
	<true/>
	<key>LSUIElement</key>
	<string>1</string>
</dict>
</plist>
```

-	`CFBundleIdentifier` needs to be set to some value for Notification Center to work.
-	The binary must be inside `Contents/MacOS` directory for Notification Center to work.
-	`NSHighResolutionCapable` to enable Retina mode.
-	`LSUIElement` is needed to make the app not appear in Cmd+Tab list and the dock
	while still being able to show a tooltip in the menu bar.

On macOS, when you run an app bundle, the working directory of the executed process
is the root directory (`/`), not the app bundle's `Contents/Resources` directory.
Change directory to `Resources` if you need to load resources from there.

```Go
ep, err := os.Executable()
if err != nil {
	log.Fatalln("os.Executable:", err)
}
err = os.Chdir(filepath.Join(filepath.Dir(ep), "..", "Resources"))
if err != nil {
	log.Fatalln("os.Chdir:", err)
}
```

Installation
------------

```sh
go get github.com/shurcooL/trayhost
```

License
-------

-	[MIT License](LICENSE)


The Best Go Libraries For GUI (25)

app