Advisory boards aren’t only for executives. Join the LogRocket Content Advisory Board today →

LogRocket blog logo

  • Product Management
  • Solve User-Reported Issues
  • Find Issues Faster
  • Optimize Conversion and Adoption
  • Start Monitoring for Free

Best GUI frameworks for Go

desktop application written in golang

Go is a statically-typed language with syntax similar to C that was designed to be efficient, reliable, and easy to use. Go is commonly used for building web servers , networking tools, and distributed systems. Go is also known for its fast compilation times, making it an excellent choice for building large-scale applications.

Best GUI Frameworks for Go

While Go is primarily used for building command-line applications, you can also build graphical user interfaces (GUIs). Several third-party GUI packages are available to create visually appealing and user-friendly GUIs. In this article, we’ll look at some of the best GUI frameworks for Go.

The 5 best GUI frameworks for Go

A GUI framework also allows developers to create cross-platform applications that can run on different operating systems with minimal modifications. This is important for developers looking to target a wide range of users, regardless of their operating system. These packages provide tools that make creating and managing graphical elements easier, such as buttons, text fields, and menus. Additionally, these frameworks can provide an easy-to-use API and abstract away the complexities of GUI development.

Go Illustration

The use of GUI frameworks also helps separate the application’s logic from the presentation, making the application more modular and maintainable. This article aims to overview popular third-party GUI development packages in Go. You’ll learn about the packages, features, and functionalities, from the GTK package to Qt, Fyne, and Walk packages.

The go-gtk Package

GTK (GIMP Toolkit) is a multi-platform toolkit for building GUIs. GTK is written in C and has bindings for various programming languages, including C++, Python, C#, and Go. GTK3 helps create desktop applications for Linux and Unix-like systems and supports macOS. The GTK project supports themeable widgets, advanced layout management, accessibility support, and internationalization support, and the package is designed to be extensible to widgets.

The go-gtk package is a Go binding for the GTK toolkit. The package enables Go developers to use the GTK library in Go with similar features as the GTK library. The package is performant, well-documented, and actively maintained. The go-gtk package depends on the GTK library to function, and you’ll need to have GTK installed on your machine to build GUI applications in Go. Head to the installations page , where you can find instructions for your OS.

After installing the GTK, run this command in the terminal of your project’s working directory to install the go-gtk package:

Here’s how you can import the go-gtk package in your Go file:

The go-gtk package is an excellent option for Go developers to create GUIs using the GTK+ toolkit. The go-gtk package provides a simple, easy-to-use API that makes it easy to take advantage of the complete feature set of GTK+ while maintaining performance.

The qt Package

Qt is a cross-platform application development framework widely used for developing desktop, mobile, and embedded systems. Qt provides a powerful, easy-to-use, and flexible C++ class library for building GUIs and other types of applications. Qt has a wide range of built-in widgets, including buttons, labels, list boxes, and more.

Qt also provides support for multiple platforms, from Windows to macOS, Linux, iOS, and Android. Qt also supports libraries for various languages, including C++, Python, and QML, with an event-driven model for creating highly responsive and interactive applications.

The qt package is a Go wrapper for the Qt library, providing a framework for creating cross-platform applications. The qt package offers many features and functions, including support for GUI components such as buttons, labels, and text fields.

The qt package wraps the Qt library (C++ based), and you’ll need to have the package installed and a C++ compiler for building and running your application. Head on to the Qt library installations page to install the Qt library to get started.

Run this command in the terminal of your project’s working directory to install the qt package:

Here’s how you can import the qt package in your Go files:

Overall, the qt package provides a powerful and flexible tool for creating cross-platform applications, allowing developers to take advantage of the performance and ease of use of Go while also using the extensive functionality of the Qt library.

The fyne Package

Fyne is an open source, cross-platform GUI toolkit written in Go. Fyne provides an easy-to-use API for creating modern, responsive graphical user interfaces that run on Windows, macOS, Linux, and mobile devices (iOS and Android).

Fyne uses the GPU of machines to accelerate rendering, making the package suitable for building high-performance applications with dynamic layouts. The package provides clipboard support, gesture events, accessibility and internationalization, and cross-platform file and directory dialogs.

Fyne’s API is designed to be easy to use, emphasizing a consistent and familiar experience across all platforms. The package includes a variety of widgets, such as buttons, labels, text inputs, and more, which can be quickly composed to create complex UIs.

The fyne package is available on GitHub , and you can install it by running this command in the terminal of your project’s working directory:

Here’s how you can import the Fyne package into your Go files:

Fyne is under active development and is gaining popularity in the Go community. The package is used in many open source and commercial projects due to its many features.

desktop application written in golang

Over 200k developers use LogRocket to create better digital experiences

desktop application written in golang

The walk package is a Go package for building GUI apps. Walk wraps the Windows API and provides a clean, high-level API for creating Windows apps in Go.

The walk package takes an event-driven approach where the app responds to user inputs and system events rather than running in a loop. The walk package also supports widgets and customized widgets for building user interfaces, such as buttons, labels, text boxes, and more, and layouts from grids, flow, and dock.

To install the walk package, run the following command:

You must be running Windows to use the walk package since walk depends on the Windows GUI library. Now, here’s how you can import the walk package in your Go files:

The walk package is flexible and customizable, providing a high-level, easy-to-use API for creating professional-looking, feature-rich Windows apps with minimal effort.

The gioui Package

Gio is an open source Go project that provides Go libraries for building graphical user interfaces (GUIs). Gio helps Go developers build efficient, fluid, and portable GUIs across all major platforms.

The tool combines bleeding-edge 2D graphics technology with the flexibility of the immediate mode graphics paradigm for creating a compelling and consistent foundation for GUI application development. The Gio project’s primary focus is providing a lightweight and efficient medium for building cross-platform GUIs that can run on various operating systems. These include WebAssembly , Android , tvOS , FreeBSD, OpenBSD, Windows, macOS, and Linux.

The gio package supports various widgets from buttons to labels, text fields, layout and styling, and touch and gesture input support. Gio also includes an efficient vector renderer based on the pathfinder project implemented on OpenGL ES and Direct3D 11. The project is migrating towards an even more efficient compute-shader-based renderer built on piet-gpu .

Gio is designed to work with a few dependencies, and the tool depends on several platform libraries for window management and GPU drawing. Run this command in the terminal of your GOPATH to install the Gio package:

You can import the various sub-packages in the Gio package depending on your use case, like so:

Gio is an excellent option for developers who build cross-platform GUI applications with Go. Its lightweight and efficient design, simple and easy-to-use API, and support for various widgets and layout options make it easy for developers to build visually appealing and responsive GUI interfaces.

Comparing Go GUI frameworks

When considering a GUI package for a project, it is essential to consider the project’s requirements, such as the target platform, desired look and feel, and performance needs.

Here are a few points about the packages you may want to consider:

  • go-gtk: A popular choice for creating desktop applications and has a large community of developers
  • fyne: Also uses the latest technologies, such as OpenGL, for rendering, which makes it perform well even on lower-end hardware
  • qt: Has a large community of developers and a wide range of supported platforms, including Windows, macOS, and Linux
  • gioui: Uses the modern GPU-based UI architecture and can be used to create mobile and desktop applications. Gioui is lightweight and has a minimalistic API
  • walk: A GUI Go library based on the Windows Presentation Foundation (WPF) framework. Walk is a good choice for creating Windows desktop applications and has a simple and easy-to-use API

Here’s a comparison table comparing the packages based on popularity, production readiness, and compatibility:

The go-gtk and fyne packages are suitable for desktop applications, while gioui is good for mobile and desktop applications. The qt and walk packages are good choices for cross-platform and Windows-specific applications, respectively.

You’ve learned about the essence of using Go for developing GUI applications, and you learned about the popular go-gtk, fyne, walk, qt, and gio third-party packages that facilitate cross-platform GUI development in Go. You also got a comparison of the GUI packages to help you choose a package for your project.

You can also build command-line applications in Go. To learn more, check out this article on u sing Cobra to build a CLI accounting app . The Cobra package is notable for building sophisticated CLI apps from Hugo to Docker and Kubernetes.

Get set up with LogRocket's modern error tracking in minutes:

  • Visit https://logrocket.com/signup/ to get an app ID

Install LogRocket via npm or script tag. LogRocket.init() must be called client-side, not server-side

Share this:

  • Click to share on Twitter (Opens in new window)
  • Click to share on Reddit (Opens in new window)
  • Click to share on LinkedIn (Opens in new window)
  • Click to share on Facebook (Opens in new window)

desktop application written in golang

Stop guessing about your digital experience with LogRocket

Recent posts:.

Extracting YouTube Video Data With OpenAI And LangChain

Extracting YouTube video data with OpenAI and LangChain

Extract YouTube video data using OpenAI and LangChain for quick, cost-effective insights without watching the videos.

desktop application written in golang

How to use CSS variables like a pro

By building these four simple projects, you’ll learn how CSS variables can help you write reusable, elegant code and streamline the way you build websites.

desktop application written in golang

How to build a component library with React and TypeScript

In this article, we’ll learn what a component library is and how to build our component library with React and TypeScript.

desktop application written in golang

Chakra UI adoption guide: Overview, examples, and alternatives

Chakra UI has emerged as a highly relevant design library. Let’s discuss what makes Chakra UI a great choice for modern applications.

desktop application written in golang

2 Replies to "Best GUI frameworks for Go"

The maintainer of the qt package for Go hasn’t had any Github activity since 2020. No PRs are being merged. I think it would be best to delist it here, or at least provide a warning (and maybe make it red and bold).

Leave a Reply Cancel reply

Search code, repositories, users, issues, pull requests...

Provide feedback.

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly.

To see all available qualifiers, see our documentation .

  • Notifications

Create beautiful applications using Go

Introduction

Getting started, stargazers over time, contributors, inspiration.

The traditional method of providing web interfaces to Go programs is via a built-in web server. Wails offers a different approach: it provides the ability to wrap both Go code and a web frontend into a single binary. Tools are provided to make this easy for you by handling project creation, compilation and bundling. All you have to do is get creative!

  • Use standard Go for the backend
  • Use any frontend technology you are already familiar with to build your UI
  • Quickly create rich frontends for your Go programs using pre-built templates
  • Easily call Go methods from Javascript
  • Auto-generated Typescript definitions for your Go structs and methods
  • Native Dialogs & Menus
  • Native Dark / Light mode support
  • Supports modern translucency and "frosted window" effects
  • Unified eventing system between Go and Javascript
  • Powerful cli tool to quickly generate and build your projects
  • Multiplatform
  • Uses native rendering engines - no embedded browser !

The project roadmap may be found here . Please consult this before open up an enhancement request.

The installation instructions are on the official website .

desktop application written in golang

Is this an alternative to Electron?

Depends on your requirements. It's designed to make it easy for Go programmers to make lightweight desktop applications or add a frontend to their existing applications. Wails does offer native elements such as menus and dialogs, so it could be considered a lightweight electron alternative.

Who is this project aimed at?

Go programmers who want to bundle an HTML/JS/CSS frontend with their applications, without resorting to creating a server and opening a browser to view it.

What's with the name?

When I saw WebView, I thought "What I really want is tooling around building a WebView app, a bit like Rails is to Ruby". So initially it was a play on words (Webview on Rails). It just so happened to also be a homophone of the English name for the Country I am from. So it stuck.

Star History Chart

The contributors list is getting too big for the readme! All the amazing people who have contributed to this project have their own page here .

FOSSA Status

This project was mainly coded to the following albums:

  • Manic Street Preachers - Resistance Is Futile
  • Manic Street Preachers - This Is My Truth, Tell Me Yours
  • The Midnight - Endless Summer
  • Gary Newman - Savage (Songs from a Broken World)
  • Steve Vai - Passion & Warfare
  • Ben Howard - Every Kingdom
  • Ben Howard - Noonday Dream
  • Adwaith - Melyn
  • Gwidaith Hen Fran - Cedors Hen Wrach
  • Metallica - Metallica
  • Bloc Party - Silent Alarm
  • Maxthor - Another World
  • Alun Tan Lan - Y Distawrwydd

Security policy

Releases 211, sponsor this project, used by 2.1k.

@oksuriini

Contributors 220

@leaanthony

  • JavaScript 6.2%
  • Objective-C 4.4%

desktop application written in golang

Creating Cross-Platform Desktop Applications with Go

Go, also known as Golang, is a powerful programming language that has gained popularity due to its simplicity, performance, and strong support for concurrency. While Go is often associated with server-side and web applications, it is also a great choice for developing cross-platform desktop applications. In this blog, we will explore the process of creating cross-platform desktop applications using Go, along with some useful libraries and tools that will streamline the development process.

Creating Cross-Platform Desktop Applications with Go

1. Why Choose Go for Cross-Platform Desktop Applications?

Before diving into the details, it’s essential to understand why Go is an excellent choice for building cross-platform desktop applications:

  • Performance: Go’s compiled nature ensures that applications written in Go perform exceptionally well, making it suitable for resource-intensive desktop applications.
  • Concurrency: Go’s built-in support for concurrency and goroutines enables developers to create responsive desktop applications that handle multiple tasks concurrently.
  • Simplicity: Go’s straightforward and minimalist syntax allows developers to focus on solving problems efficiently without getting bogged down by unnecessary complexities.
  • Cross-Platform Support: Go’s strong support for cross-compilation allows developers to create applications that run seamlessly on Windows, macOS, and Linux without modification.
  • Large Standard Library: Go’s standard library offers a wide range of functionalities, including networking, file handling, and cryptography, reducing the need for third-party dependencies.

2. Setting Up Go for Desktop Application Development

Before we start building desktop applications, make sure you have Go installed on your system. You can download and install the latest version of Go from the official website (https://golang.org). After installation, ensure that you’ve set up the necessary environment variables to access Go from the command line.

To verify that Go is correctly installed, open a terminal or command prompt and type:

If you see the installed Go version, you’re ready to proceed.

3. Building a Simple Cross-Platform Desktop Application

Let’s create a basic cross-platform desktop application that displays a window with a “Hello, World!” message using Go and the popular GUI library, “fyne.io/fyne.”

3.1. Installing the Fyne Library

To get started, we need to install the Fyne library, which provides a simple and straightforward way to build cross-platform GUI applications. Open a terminal or command prompt and execute the following command:

3.2. Creating the Desktop Application

Now that Fyne is installed, we can proceed to create our “Hello, World!” desktop application.

3.3. Running the Application

Save the above code in a file named “hello.go.” To build and run the application, use the following command:

You should see a window displaying the message “Hello, World!” Congratulations! You have successfully built a cross-platform desktop application using Go and Fyne.

4. Exploring More Features with Fyne

Fyne provides an array of widgets and layouts to design visually appealing desktop applications. Let’s explore a few additional features:

4.1. Creating a Responsive Layout

Fyne allows you to create responsive layouts that adapt to different screen sizes. Let’s modify our previous example to include multiple widgets in a grid layout.

4.2. Handling Events

Adding interactivity to your desktop application is easy with Fyne. Let’s modify our application to handle button clicks.

5. Packaging and Distributing Your Application

Once you have developed your cross-platform desktop application using Go and Fyne, you may want to package and distribute it to users.

5.1. Cross-Compiling Your Application

To create binary executables for different operating systems, you can use Go’s built-in cross-compilation support. For example, to build an executable for Windows from a macOS or Linux machine, use the following command:

5.2. Distributing Your Application

To distribute your application, create an installer for each platform using platform-specific packaging tools. For example, use Inno Setup for Windows, PackageMaker for macOS, and .deb/.rpm packages for Linux distributions.

Alternatively, you can consider using Go’s “gotham” tool, which simplifies the process of packaging and distributing Go applications on different platforms.

In this blog, we’ve explored how Go can be utilized to develop efficient and cross-platform desktop applications. With the Fyne library, creating visually appealing GUIs and handling user events becomes a breeze. Go’s powerful concurrency and cross-compilation support add more value to the development process. Whether you’re a seasoned Go developer or just getting started, building cross-platform desktop applications with Go is an exciting and rewarding journey. Happy coding!

desktop application written in golang

Table of Contents

Top 15 sites to hire Go developers

Introduction to Go’s Context Package: Managing Application State

Introduction to Go’s Context Package: Managing Application State

Introduction to Go’s Net/HTTP Package: HTTP Client and Server

Introduction to Go’s Net/HTTP Package: HTTP Client and Server

Build a cross-platform desktop application with Go and Wails

Time to read: 11 minutes

  • Facebook logo
  • Twitter Logo Follow us on Twitter
  • LinkedIn logo

Build a Cross-Platform Desktop Application With Go and Wails

Electron was (and still is) a big hit for a number of reasons. First, its cross-platform functionality enables developers to support Linux, Windows, and macOS from a single codebase. On top of that, it has a lean learning curve for developers familiar with Javascript.

While it has its downsides — with application size and memory consumption the most prominent — it has opened up a wealth of possibilities for creating cross-platform desktop apps.

However, since its release, a number of alternatives have come into the fray. This article explores one such alternative - Wails , a project which makes it possible to write desktop apps using Go and web technologies such as React and Vue. A major selling point for Wails is that it does not embed a browser, but instead uses the native rendering engine for the platform. This makes it a lightweight alternative to Electron .

To get familiar with Wails, you will build a GitHub desktop client which will interact with the GitHub API , providing the following features:

  • View public repositories and Gists
  • View private repositories and Gists for an authenticated user
  • Create a new Gist for the authenticated user.

While the backend will be written in Go, React  and Vite  will be used for the frontend. The UI components will be created using Ant Design (AntD) .

How it works

As mentioned earlier, Wails works by combining a backend written in Go with a frontend written using either a Javascript library/framework, or with Vanilla HTML and Javascript. Even though your functions and data types are declared on the backend, Wails makes it possible for them to be called on the frontend. What’s more, where a struct is declared on the backend, Wails is able to generate a TypeScript  model for use on the frontend. The result of this is seamless communication between the frontend and backend. You can read more about how Wails works here .

Prerequisites

To follow this tutorial, you will need the following:

  • A basic understanding of Go  and React
  • An up-to-date installation of Wails

Getting started

Create a new Wails project by running the following command.

This scaffolds a new project using Go for the backend and React + Vite for the frontend. Once the scaffolding process is completed, navigate into the newly created folder and run the project, by running the commands below.

This will run the application as seen in the image below.

The initial Wails app running on macOS

Close the application and open the project directory in your preferred editor or IDE, to get started with adding features to the application.

Build the backend

Add functionality for api requests.

The first thing the app needs to have is the ability to send GET and POST requests to the GitHub API. In the root directory of the application, create a new file named api.go . In this file, add the following code.

The makeRequest() function is used internally to make a request to a specified URL. In addition to specifying the URL, the request type, token, and payload are passed to the function. Using these, the request is prepared and sent with the API response returned by the function.

The MakeGetRequest() and MakePostRequest() functions wrap around the makeRequest() function to send GET and POST requests respectively.

Bind helper functions to the app

With the API functionality in place, you can declare some helper functions which will be bound to the frontend. This is done by adding receiver functions for the App struct.

You can see an example of this at the end of app.go , where a receiver function named Greet() is declared.

Now, add the following code to app.go .

Then, add "encoding/json" to the imports list at the top of the file, if your text editor or IDE doesn't do it for you automatically.

In addition to the existing code, it declares two new types: APIResponse and Gist . These will be used to model a response from the API and the structure of a Gist respectively. Next, it declares the receiver functions for the App struct:

  • The GetPublicRepositories() function retrieves a list of public repositories from the GitHub API via a GET request. Since this route does not require authentication, an empty string is passed as the token.
  • The GetPublicGists() function retrieves a list of public Gists from the GitHub API via a GET request. Authentication is also not required, hence an empty string is passed as the token.
  • The GetRepositoriesForAuthenticatedUser() function is used to get a list of the authenticated user’s private repositories. This function takes the token as a parameter.
  • The GetGistsForAuthenticatedUser() function is used to retrieve the authenticated user’s Gists. This function also takes a token as a parameter.
  • The GetMoreInformationFromURL() function is used to get more information on a repository. This information could be the commit history, list of contributors, or list of users who have starred the repository. It takes two parameters, the url to be called and the authentication token. For public repositories, the token will be an empty string.
  • The GetGistContent() function is used to get the content of a Gist. This function takes the URL for the Gist’s raw content and an authentication token (an empty string for public Gists). It returns a string corresponding to the content of the Gist.
  • The CreateNewGist() function is used to create a new Gist for the authenticated user. This function takes two parameters, the Gist to be created as well as the authentication token for the user.

Build the frontend

All the code for the frontend is stored in the frontend  folder. But before writing any code, add the JavaScript dependencies using the following commands.

The dependencies are as follows:

  • Ant Design  - This helps designers/developers to build beautiful and flexible products with ease
  • Ant-design icons  - This gives you access to AntD’s SVG icon collection
  • React-router  - This will be used to implement client-side routing
  • Prismjs  - This will be used to implement syntax highlighting for the Gists

Next, create a folder in the frontend/src  folder named components .

Add authentication

For authentication, the user will be required to provide a GitHub Personal Access Token . The token is included in the header of requests to endpoints requiring authentication. Create one if you don’t have one — however, you must set the following permissions for your token to be useful for this project.

The required GitHub Personal Token settings

For this project, the React Context API  will be used to store the token for an hour after which the user will have to re-authenticate by providing the token again.

In the frontend/src/components  folder, create a new folder named context . In that folder, create a new file named AuthModal.jsx  and add the following code to it.

This component renders the authentication form. The form has a single field for the user to paste and save a token. The shouldShowModal prop is used to conditionally render the form while the onSubmit and onCancel props are used to respond to the user’s action.

Next, in the context  folder again, create a new file named AuthContext.jsx  and add the following code to it.

There are two exports in this file. The first is the useAuthContext hook. This hook will be used to retrieve the token saved in Context . The second is the AuthContextProvider component. This component is responsible for rendering the authentication form (either on page load or when the token has “expired” after 1 hour).

It also renders an error page if the user clicks “ Cancel ” on the authentication form. This component takes a JSX element (named children ) as a prop and wraps it with a context provider — thus giving the child element access to the value of the token.

Add the Master-Detail layout

For displaying repositories and Gists, the master-detail layout will be used. A list of items will be rendered and clicking on one item will display more information on the selected item beside the list.

In the components  folder, create a new file named ListItem.jsx  and add the following code to it.

This component renders a single item in the list using the AntD Card  component. The title of the card is provided as a component prop. In addition to the title, this component receives three other props:

  • The onSelect prop is used to notify the parent item that the card has been clicked
  • item corresponds to the gist or repository which will be rendered on the card
  • selectedItem is used by the component to determine if the rendered item was clicked by the user; in which case a light blue background is added to the card styling.

Next, create a new file named MasterDetail.jsx  in the components  folder and add the following code to it.

This component is responsible for rendering the list of items in one column and the details of the selected item in another column. The items to be rendered are provided as a prop to the component.

In addition to that, the getItemDescription() prop is a function to get what will be displayed under the user avatar; this is the repository name or the Gist description.

The detailLayout() prop is a function provided by the parent component which returns the JSX content for the detail section based on the provided item. This allows Gists and repositories to have entirely different layouts while using the same child component for rendering.

Add repository-related components

Next, in the components  folder, create a new folder named Repository  to hold components related to a repository. Then, create a new file named RepositoryDetails.jsx  and add the following code to it.

Next, create the component for rendering public repositories. In the components/Repository  folder, create a new file named PublicRepositories.jsx  and add the following code to it.

This component makes the call to retrieve public repositories from the GitHub API. It does this using the GetPublicRepositories() function declared in app.go  which is automatically bound to the frontend by Wails.

Functions exported in this manner are asynchronous  and return a Promise . Using the MasterDetail and RepositoryDetails components, the returned response is rendered accordingly.

Next, create another file named PrivateRepositories.jsx  in the Repository  folder and add the following code to it.

This component is very similar to the PublicRepositories  component but for two key things. First, this component will be wrapped with an AuthContextProvider , which makes it possible to retrieve the saved token via the useAuthContext hook. Second, it uses another bound function GetRepositoriesForAuthenticatedUser() to get the repositories for the user whose token was provided.

Add Gist related components

Next, in the components  folder, create a new folder named Gist  to hold components related to a Gist. Then, in that new folder, create a new file named GistDetails.jsx  and add the following code to it.

This component renders the code in the file(s) for a given Gist. Every Gist response comes with a files key. This is an object containing all the files for the Gist. Each file object contains the URL to the file’s raw content and the language associated with the file. This component retrieves all the files using the GetGistContent() function and renders them in a Carousel. Prism  is used to render the code as would be found in an IDE.

Next, in the Gist folder, create a file named PublicGists.jsx  and add the following code to it.

Just as was done for the rendering of public repositories, the GetPublicGists() function declared in app.go  is used to retrieve public Gists from the Github API and pass them to the MasterDetail component, along with the functions to get the Gist description and display more information on the Gist when selected.

Next, create a new file named PrivateGists.jsx  in the Gist  folder and add the following code to it.

This component will be wrapped with an AuthContextProvider component, thus giving it access to the provided token. Using the token, an asynchronous call is made to the GitHub API via the GetGistsForAuthenticatedUser() function. The results are then passed to the MasterDetail component along with the other required props for appropriate rendering.

The last Gist related component to be built is the form to create a new Gist. To do this, create a new file named CreateGist.jsx  in the Gist  folder and add the following code to it.

The request to create a new Gist has three fields:

  • description : Where provided, this will describe what the code in the Gist aims to achieve. This field is optional and is represented in the form by an input field
  • public : This is a required field and determines whether or not the Gist has public access. In the form you created, this is represented by a switch which is set to off  by default. This means that unless otherwise specified by the user, the created Gist will be secret and only available to users who have its link.
  • files : This is another required field. It is an object and for each entry in the object, the key is the name of the file (with the extension included) and the value is the content of the file. This is represented in the form you created as a dynamic list with each list item consisting of a text field for the file name and a text area for the file content. By clicking the Add File  button, you have the ability to add multiple files. You also have the ability to delete a file. Note that you will be required to have at least one file and if you do not, an error message will be displayed.

When the form is properly filled out and submitted, the onFinish() function is used to create an object conforming to the Gist struct declared in app.go  and a call is made to the CreateNewGist() receiver function.

Because this component is wrapped with the AuthContextProvider , the saved token can be retrieved and passed alongside the Gist as required by the function. Once a successful response is received, the app redirects to the list of Gists for the authenticated user.

Put the pieces together

Add navigation.

With all the individual components in place, the next thing to add is navigation - a means by which the user can move around the application. To add this, create a new file in the components  folder named NavBar.jsx  and add the following code to it.

This component renders a navigation bar at the top of the window with two main items - Public Actions  and Private Actions . Each item then has sub-items, which are links that will eventually render the component associated with the sub-item. With this in place, you can add routing to your application.

Add routing

In the frontend/src  folder, create a new file named routes.jsx  and add the following code to it.

Here, you specified the routes in the application as well as the component to be rendered for each path. In addition to that, you have wrapped the components which require the user to provide a token with the AuthContextProvider component.

Next, open App.jsx  and update the file's code to match the following.

Here, you have included the NavBar component you declared earlier. You also declared an Outlet component which is provided by react-router-dom to render child route elements.

Finally update the code in main.jsx  to match the following.

A HashRouter  is the officially recommended approach for routing . This is created via the createHashRouter() function. Using the routes object you declared earlier, all router objects are passed to this component to render your app and enable the rest of the APIs. With this in place, your application will render the index page once it loads.

Test that the application works

You’ve successfully built your first app with Wails . Run the application again and take it for a spin by running the following command from the project's top-level folder.

By default, when the app loads, you will be greeted with a list of public repositories. Using the navigation menu, you can view public (and private) repositories and Gists by clicking the corresponding menu item.

When you select a menu item for a private repository or private Gist, a pop-up will be displayed asking for your GitHub token as shown below.

The personal access token dialog visible in front of the Wails application.

Paste your Personal Access Token (PAT) and click Save . Your repositories (or Gists as the case may be) will then be rendered. You will be able to navigate around the private section of the app without having to re-enter your token for a few minutes.

And that's how to build a cross-platform desktop application with Go and Wails

There’s still a lot you could do. For example, how would you handle ensuring that the token provided by the user is valid before trying to perform authenticated actions?

What other features do you think you can add to the application? Did you know that you could make further customizations to the app such as the width and height, or even start off in full-screen mode? Have a look at the Options  documentation to see how you can further configure your app.

In case you get stuck at any point, feel free to access the codebase here .

I’m excited to see what more you come up with. Until next time ✌🏾

Joseph Udonsak is a software engineer with a passion for solving challenges – be it building applications, or conquering new frontiers on Candy Crush. When he’s not staring at his screens, he enjoys a cold beer and laughs with his family and friends.

Related Posts

A man in an IDE on a desktop computer

Related Resources

Twilio docs, from apis to sdks to sample apps.

API reference documentation, SDKs, helper libraries, quickstarts, and tutorials for your language and platform.

Resource Center

The latest ebooks, industry reports, and webinars.

Learn from customer engagement experts to improve your own communication.

Twilio's developer community hub

Best practices, code samples, and inspiration to build communications and digital engagement experiences.

Let's code

Programming guides, examples and tips

Fyne (Golang) desktop app with goroutines

Golang is really not the best choice when it comes to developing desktop apps, but it is still possible. One example of viable use case for Golang desktop app would be to quickly add graphical interface for existing CLI app. And Fyne is great framework for that purpose. As stated on their official GitHub page, it’s 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.

Few months ago I was building an desktop app using Fyne framework. That app was using background goroutine to do some work and report back results to main goroutine via channel. Background worker was running without interruption and main goroutine would just receive and display results until background worker is done with it’s job. Everything was working fyne (pun intended), until I had to interrupt background worker in the middle of the run to send it some additional data that was not available at the start. Idea was to have background worker send signal to main goroutine to get required data. Main goroutine would then show dialog to user to enter data. And finally, main goroutine would send entered data back to background worker. My first solution was something like this (simplified example):

If you try to run this code, when you click that big button, dialog to enter data will be spawned, but then whole app will stuck and there is nothing you can do but kill process. I was stuck (just like my app) and had no idea how to proceed. With the help of Fyne framework creator on Fyne official Slack channel , I managed to find solution. It was so simple to fix it, but I didn’t saw it. So I decided to share it here, if someone else will have the same problem. All that’s needed to be done is to change line 30, from listen(chn) to go listen(chn) so listen function will also run in separate goroutine which will stop it from blocking the events goroutine. And that’s it, now everything works as expected 🙂

Share this:

  • Click to share on Facebook (Opens in new window)
  • Click to share on Twitter (Opens in new window)
  • Click to share on LinkedIn (Opens in new window)
  • Click to share on Reddit (Opens in new window)
  • Click to share on Tumblr (Opens in new window)
  • Click to share on Pinterest (Opens in new window)

Leave a comment Cancel reply

' src=

  • Already have a WordPress.com account? Log in now.
  • Subscribe Subscribed
  • Copy shortlink
  • Report this content
  • View post in Reader
  • Manage subscriptions
  • Collapse this bar

GUI - Awesome Go

Libraries for building GUI Applications.

Netlify Status

  • app - Package to create apps with GO, HTML and CSS. Supports: MacOS, Windows in progress.
  • energy - Cross-platform based on LCL(Native System UI Control Library) and CEF(Chromium Embedded Framework) (Windows/ macOS / Linux)
  • fyne - Cross platform native GUIs designed for Go based on Material Design. Supports: Linux, macOS, Windows, BSD, iOS and Android.
  • gio - Gio is a library for writing cross-platform immediate mode GUI-s in Go. Gio supports all the major platforms: Linux, macOS, Windows, Android, iOS, FreeBSD, OpenBSD and WebAssembly.
  • go-astilectron - Build cross platform GUI apps with GO and HTML/JS/CSS (powered by Electron).
  • go-gtk - Go bindings for GTK.
  • go-sciter - Go bindings for Sciter: the Embeddable HTML/CSS/script engine for modern desktop UI development. Cross platform.
  • Goey - Cross platform UI toolkit aggregator for Windows / Linux / Mac. GTK, Cocoa, Windows API
  • goradd/html5tag - Library for outputting HTML5 tags.
  • gotk3 - Go bindings for GTK3.
  • gowd - Rapid and simple desktop UI development with GO, HTML, CSS and NW.js. Cross platform.
  • qt - Qt binding for Go (support for Windows / macOS / Linux / Android / iOS / Sailfish OS / Raspberry Pi).
  • ui - Platform-native GUI library for Go. Cross platform.
  • unison - A unified graphical user experience toolkit for Go desktop applications. macOS, Windows, and Linux are supported.
  • Wails - Mac, Windows, Linux desktop apps with HTML UI using built-in OS HTML renderer.
  • walk - Windows application library kit for Go.
  • webview - Cross-platform webview window with simple two-way JavaScript bindings (Windows / macOS / Linux).
  • AppIndicator Go - Go bindings for libappindicator3 C library.
  • gosx-notifier - OSX Desktop Notifications library for Go.
  • mac-activity-tracker - OSX library to notify about any (pluggable) activity on your machine.
  • mac-sleep-notifier - OSX Sleep/Wake notifications in golang.
  • robotgo - Go Native cross-platform GUI system automation. Control the mouse, keyboard and other.
  • systray - Cross platform Go library to place an icon and menu in the notification area.
  • trayhost - Cross-platform Go library to place an icon in the host operating system's taskbar.
  • zenity - Cross-platform Go library and CLI to create simple dialogs that interact graphically with the user.

A GUI can be created with a go package. There is no native support. There are several packages for making go gui’s. The most common are web-based and desktop-based.

Many apps are going in the web-based direction, think Google apps or Cloud apps. One advantage of this is that apps will work on many different operating systems (Mac, Windows). Which package is best depends on your needs.

Web based Go GUI

The app package can create apps with GO, HTML and CSS.

It’s designed to use a driver. A driver contains allows the app package to work on a platform. There seems to be only a MacOS and web driver. Meaning other platforms are not supported.

go-astilectron

The go-astilectron package is an Electron based setup. You can make an app with HTML/JS/CSS and it’s cross platform

Electron is made with Node.js and Chromium . That means your app will run inside a special Chromium browser.

Astilectron is an Electron app, it provides an API over a TCP socket that allows executing Electron’s method as well as capturing Electron’s events.

Go-astilectron are Go bindings for the Astilectron app.

There is a demo app which shows a rather nice interface.

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

This is essentially a Go binding for Sciter . This (commercial) package can made cross-platform and embeddable user interface with JavaScript, CSS, HTML.

Desktop UI with GO, HTML, CSS and NW.js. Apps made with gowd are cross platform.

The main component here is NW.js (previously known as node-webkit). Use Node.js modules directly from DOM.

It runs on all major platforms and uses a combination of Chromium and Node.

Desktop based Go GUI

Bindings to the gtk package . This is a desktop package often used in Linux (gnome interface).

You can create GUI interfaces that have the GTK widgets. Bare in mind that not all widgets have been binded (see website).

Gtk3 is the newest version of Gtk. There are Go bindings for GTK3.

The package comes with several examples .

It requires: * GTK 3.6-3.16 * GLib 2.36-2.40 * Cairo 1.10 or 1.12 * A recent Go (1.3 or newer)

Qt binding for Go (support for Windows / macOS / Linux / Android / iOS / Sailfish OS / Raspberry Pi). QT is a popular (commercial) framework for building cross platform apps.

There’s a gallery with some examples apps.

A tiny cross-platform webview library for Golang to build modern cross-platform GUIs. It’s cross platform and platform-native, but very basic.

Windows application library kit for Go . You can make native Windows apps with this, but no other operating system is supported.

Cross-platform webview window with simple two-way JavaScript bindings (Windows / macOS / Linux). This is based on WebKit (Gtk/Cocoa) and MSHTML (Windows).

desktop application written in golang

Golang Desktop App: Webview vs. Lorca vs. Electron

Graham Jenson

Graham Jenson

I want to build a local desktop Golang app, there are a few ways to do this:

  • Electron : bundled Node.js and the Chromium browser to create a packaged local web-app. Usable with Golang frameworks like go-app or go-astilectron .
  • Lorca : using the locally installed Chrome driving it using its d ev-tools communication protocol .
  • Webview : create a native window with webview and render the app inside it using CGo bindings.

I have already written about building a simple electron app , so this post will go into how to build an app using Lorca and Webview, and then compare the three different options.

A simple Lorca app in Go looks like:

This is remarkably simple for the complexity it is hiding! The above opens a Chome window, connects over a websocket to its dev-tools endpoint, sends the HTML to load, and provides the communication between Go and JS:

What is even more cool is that you can call a JS function inside chrome and get the output in Go(!) :

Using this library was so easy, so intuitive, so functional, that I was confused when it just worked. I thought there must be a catch, something complicated that I was missing. But no, it just worked.

An additional bonus is that you get the chrome dev tools to help debug any issues or adjust the layout. Also, I love the use of JS promises to implement the async calls between Go and JS, given I have been writing about promises since 2014 .

The big downside to Lorca is that because it uses Chrome, some application details (like the system menu, icon, title) cannot be customized. The tradeoff is then between application polish and a simple application. Depending on what you are trying to build this might be a deal-breaker, e.g. it would be fine if you are building an internal tool, but for an enterprise application this might not look great.

Webview is a library that helps building a web app directly on top of a native components. The code to do this looks like:

This is very similar API to Lorca, which I assumed was based on webview. Though unlike Lorca, the output is a bit different:

You can see the in the above screen shot the webview application window has no drop shadow, has no border, and it is initialized in the bottom left corner of the screen. This can be customized through the Window method that returns an unsafe.Pointer to the OS dependent window object ( NSWindow in macOS). This is where the difficulty begins.

To work with the Window object we must write binding from Go to the native component. For example, if we wanted our window to start centered, we would call center on the NSWindow . So we need to write a binding in three files (adapted from gogoa ):

ns_window.go

ns_window.h

ns_window.m

Then in the main() function we can center the window with:

Unlike Lorca, webview can be fully customized for our application. The problem is that it requires a bit of work.

There are a few other parts of webview that make working with it a bit difficult:

  • If using Bazel and gazelle, webview 's generated Build.bazel file is incorrect and clinkopts = [“-framework WebKit”] must be patched.
  • Calling w.Init only works when w.Navigate is called, but then the w.Eval calls stop working.
  • To set the title you could write a binding as described above, or you have to use the Dispatch method e.g. w.Dispatch(func() { w.SetTitle("Title") }) . This is incorrect in the provided examples.

I am not sure how much of this is webview and how much is NSWindow . More investigation and learning on my part should make it clearer why these things are happening.

My previous post was about building a simple Electron app that looks like:

Electron is used in many large products like VSCode. This is probably because bundling everything into a single application makes portability much simpler and applications can be extensively customized. The downside of bundling the app with a browser and Node.js is that it makes the distribution very large.

Getting Golang to play with Electron is also a bit difficult. There are frameworks that make this easier, like go-astilectron , but these are complicated and mostly feature incomplete. Another way might be to use Golang compiled to WASM, which I wrote about before , but this is also not a simple solution.

The benefits of Electron are that it is portable, customizable, and battle tested for application distribution. It is just a bit complicated with Golang.

I think the main comparison to be made is customizability vs. simplicity. Lorca is by far the simplest with very limited customizability, webview can be fully customized with some difficulty, and Electron is fully customizable but difficult to use with Golang.

Also the size of the bundle is very different between the frameworks; Lorca has a 8.7 MB binary, webview 3.7Mb , and Electron a 157Mb bundle size. The debugging tools also vary: Lorca and Electron use the Chrome dev tools, where webview uses the Safari dev tools.

Conclusion:

Both Lorca and webview work well with Golang, have small distribution sizes, and similar APIs. The main difference is between the underlying renderer being native and debug tooling.

Electron I think is probably too complicated to use with Golang without a lot of difficulty.

A potential workflow is to use Lorca during development and webview for distribution. Lorca provides familiar tooling for debugging and development, where webview provides the customizability for distribution. Lorca would also be a nice backup as a means of cross-compilation to other operating systems that webview does not support.

Note: there are still more options like wails or gotk that can provide other means to build/distribute apps.

Graham Jenson

Written by Graham Jenson

New Zealand Programmer, Dad, DevOps, Data, Scale Everything

More from Graham Jenson and Maori Geek

How “go build” Works

How “go build” Works

How does go build compile a golang program this post is here to answer that question..

JQuery Promises and Deferreds: I promise this will be short

JQuery Promises and Deferreds: I promise this will be short

Game Of Life: CUDA vs Golang

Game Of Life: CUDA vs Golang

Which is faster to run game of life, cuda or golang tldr: cuda wins … by a lot..

How to Digest a Docker Image

How to Digest a Docker Image

How to calculate and manipulate docker sha digests, recommended from medium.

Golang Backend (Image Upload API)

Muhammad Adeel

Golang Backend (Image Upload API)

How to handle image upload in golang using fiber framework.

Golang CRUD REST API with Echo

Dewi Rahmawati

Stackademic

Golang CRUD REST API with Echo

Golang is a popular programming language these days. we can use golang to create a rest api. so, we are going to build a crud rest api in….

desktop application written in golang

General Coding Knowledge

desktop application written in golang

Stories to Help You Grow as a Software Developer

desktop application written in golang

Coding & Development

desktop application written in golang

Artturi Jalli

I Built an App in 6 Hours that Makes $1,500/Mo

Copy my strategy.

Installing Nginx on Windows — A Step-by-Step Guide

Chandramathi Muthuraj

Installing Nginx on Windows — A Step-by-Step Guide

Are you looking to set up nginx on your windows machine for web development or testing purposes.

Personal Blog with HTMX + Go Part 1 — Golang Templating Setup

Muhammad Wyndham Haryata Permana

Gravel Product & Tech

Personal Blog with HTMX + Go Part 1 — Golang Templating Setup

This will be the part 1 of many on my htmx + go journey.

Go Gin vs Fiber: Hello World performance

Mayank Choubey

Go Gin vs Fiber: Hello World performance

Find out who’s faster for a simple hello world case: gin or fiber.

Text to speech

GUI in Go

Writing GUIs in Golang

  • Posted on May 20, 2021

GeekThis remains completely ad-free with zero trackers for your convenience and privacy. If you would like to support the site, please consider giving a small contribution at Buy Me a Coffee .

This post will cover how you can write a user interface in Go. I’ll go over the different methods to code a UI, the available modules, and if you should even use Go for these types of applications.

Go isn’t usually thought of when creating a GUI application, but it is possible and I have written a few GUI applications myself with Go. The reason for it was that with Go I could quickly code all of my business logic and the GUI that was required for the problem was simple.

Should Golang be used for GUI Applications?

Honestly, writing a GUI application in Go is fine. For cross-platform applications, I’d suggest using Go bindings for GTK. There isn’t any added complexity compared to coding GTK in C, and the performance seems fine from my experience with writing business applications.

For why you may not want to use Go for GUI applications, there aren’t many. Coming from a C background, garbage collection in Go can be frustrating since I can’t free unused widgets and windows. Another reason is there isn’t as much support for GUIs in Go. I’ve only worked with simple programs that didn’t need OpenGL custom drawing, and regular widgets work well.

Golang GUI Options

Below are a few different methods you can use for writing a GUI in Go and the reasons for and against using them. It’s important to code your GUI separate from the rest of your code and employ a good programming pattern to keep your code organized. It’s crucial that you can update your models or GUI without having to rework other parts of your program.

Web Server Method

In this method, you’ll have your program start a web server using net/http and use HTML, CSS, and text/template to create a user interface (essentially a website). The Go application can then interact with the website UI using WebSockets or through ajax requests. It’s also possible to simply treat the program as a website and use forms on the site to process tasks.

  • All the modules are already available in Go
  • HTML and CSS are fantastic markup languages.
  • Quick and easy to get a GUI coded.
  • Allows multiple users to access the program at once if made public.

Disadvantages

  • You need to access your UI through a web browser.
  • Your program goes from being written in Go to being written in Go, HTML, CSS, and possibly JavaScript.
  • You’ll need to code either WebSockets or an API for the UI to interact with the program.
  • Using hardware devices becomes challenging to integrate. For instance, having a barcode scanner will require you to read the serial connection from the Go application and then send a WebSocket request to the user’s webpage. Then you’ll need JavaScript to handle the event.
  • The UI will lack basic window manager features. You’ll be unable to focus the window, prevent the window from being closed, and resizing the window automatically.

It’s probably best to avoid this method unless you are set on using HTML and CSS for your UI and don’t want additional libraries or the overhead of running an isolated browser. For some situations this method works perfectly.

HTML, CSS, and JavaScript with Isolated Browser

This method is the same as the Web Server method above, but you’ll use an isolated browser as your GUI. For instance, you could use Electron, Muon , Wails , Lorca , or another framework that allows HTML, CSS, and JavaScript to run as a desktop application. At this point, you should also consider coding the program in JavaScript.

  • The program will be a traditional UI.
  • Avoid WebSockets with JavaScript Bindings in some libraries compared to the Web Server method.
  • Adds extra complexity to the application because of multiple languages.
  • The UI will still run a web browser as your UI.
  • Performance is slower.

I’d rate this method higher than the Web Server method, primarily since you can code JavaScript bindings to avoid WebSocket and API nonsense. For traditional GUIs, view your options before settling on this method.

GTK Bindings

GTK bindings use the popular GTK library with Go bindings. GTK is verbose, but it’s no different than if you were to write it in C. As of 2021, gotk3 seems to be the most active module to use.

  • Cross-platform user interface.
  • Less overhead since it doesn’t run external applications to render the user interface.
  • The application can be written entirely in Go.
  • GTK takes a bit longer to write than HTML and CSS.
  • Go’s garbage collection could keep windows and widgets allocated that you no longer need.
  • GTK isn’t thread-safe.

I’ve written a few programs with GTK Go Bindings. Nothing too complex, just a few hundred widgets, controls, dialogs, and multiple windows. I find it works well. Keep in mind that GTK isn’t thread-safe, but there are many ways you can still run background tasks independently of the UI.

You could write your UI in C and then write the Go bindings to interact with the UI. I haven’t needed this amount of control of flexibility with C libraries yet. This method should work if you want to use Qt, GTK, Xlib, or even SDL without coding individual bindings for each of those libraries.

  • Lots of support from existing GUI libraries and different options available.
  • The program will have good performance.
  • The program will work as a traditional UI.
  • There will be additional code complexity.

This method would likely work well for applications with a complex GUI with many tasks that you want to code using Go. It’s worth considering writing the entire program in C.

Additional Libraries

Below are additional libraries that can be used to code GUIs in Golang. Some of these libraries have minimal support and activity and you should use vendoring if you decide to use them. It’s beneficial to create your own UI wrapper so you can swap out UI libraries in the future.

  • go-gtk (deprecated): This is a module of Go bindings for GTK. It has been deprecated but has good examples.
  • gotk3: This is a module of Go bindings for GTK. This module supports almost all GTK functions and has a good 1:1 mapping of function names.
  • wxGo (deprecated): wxWidgets bindings for Go. This module hasn’t been updated since 2011.
  • xgb: X bindings for Go. If you want to code a minimal UI library, this is probably a good starting point.
  • x-go-binding: X Go Bindings.
  • termbox-go: A pure Go implementation of termbox. This module is used to code a Terminal UI.
  • andlabs/ui: A minimal library for coding UI that uses the pkgui C library.
  • gxui: Google’s experimental UI library for Go.

Coding a UI in Go is fine. There are a lot of different ways to go about it each with its own advantages and drawbacks. Just don’t force yourself into using a language if there is a better language for the job.

My advice is to write your own wrapper and interfaces, then use one of the above libraries. This will make it much easier to use different UI libraries in the future since many of them don’t seem to have much support or activity.

Related Posts

Generating random numbers, strings, and more in hugo.

Create random numbers, random strings, fetch random items in slices, and generate repeatable seeds within the Hugo static site generator.

USB Sniffing and Programming

Learn how to sniff USB data and write programs to use custom USB devices. Using Wireshark and LibUSB you can fairly quickly learn how USB devices work and interact with them.

Improving Website Pagination Speed with MySQL

This post explores methods to make your pagination implementation more efficient to speed up your website and put less work load on your database.

Build Script for Hugo Websites

A basic bash build script for Hugo websites to compress images, JavaScript files, and CSS before releasing your website to the public. Keeps a copy of uncompressed assets while easily compressing all files before uploading your website.

DEV Community

DEV Community

Alex Pliutau

Posted on May 6, 2019

Building Desktop App in Go using Wails

wails+golang

This post is a text version of packagemain #6: Building Desktop App in Go using Wails video.

As we all know, Go is mostly used to build APIs, web backends, CLI tools. But what's interesting is that Go can be used in places we were not expecting to see it.

For example, we can build a Desktop App with Go and Vue.js using Wails framework.

This framework is new and still in beta, but I was surprised how easy it was to develop, build and package an app with it.

Wails provides the ability to wrap both Go code and a web frontend into a single binary. The Wails CLI makes this easy for you, by handling project creation, compilation, and bundling.

We will build a very simple app to display CPU Usage of my machine in real time. And if you have time and like Wails, you can come up with something more creative and complex.

Installation

Wails CLI can be installed with go get . After installation, you should set it up using wails setup command.

Then let's bootstrap our project with the name cpustats :

Our project consists of Go backend and Vue.js frontend. main.go will be our entrypoint, in which we can include any other dependencies, there is also go.mod file to manage them. frontend folder contains Vue.js components, webpack and CSS.

There are 2 main components to share data between Backend and Frontend: Binding and Events.

Binding is a single method that allows you to expose (bind) your Go code to the frontend.

Also, Wails provides a unified Events system similar to Javascript's native events system. This means that any event that is sent from either Go or Javascript can be picked up by either side. Data may be passed along with any event. This allows you to do neat things like have background processes running in Go and notifying the frontend of any updates.

Let's develop a backend part first, to get CPU Usage and send it to the frontend using bind method.

We will create a new package and define a type which I'll expose (bind) to the frontend.

pkg/sys/sys.go:

If your struct has a WailsInit method, Wails will call it at startup. This allows you to do some initialisation before the main application is launched.

Import sys package in main.go and bind Stats instance to frontend:

We bind the stats instance from Go, which can be used in frontend by callind window.backend.Stats . If we want to call a function GetCPUUsage() it will return us a Promise.

To build the whole project into single binary we should run wails build , -d flag can be added to build a debuggable version. It will create a binary with a name matching the project name.

Let's test if it works by simply displaying the CPU Usage value on the screen:

We sent CPU Usage value to frontend using Binding, now let's try different approach, let's create a timer on Backend which will send CPU Usage values in the background using Events approach. Then we can subscribe to the event in Javascript.

In Go we can do it in WailsInit function:

In Vue.js we can subscribe to this event when component is mounted (or any other place):

It would be nice to display CPU Usage with a gauge bar, so we will include a third party dependency for that, simply by using npm :

Then import it to main.js file:

Now we can display our CPU Usage using apexcharts, and update the values of the component by receiving an event from Backend:

To change styles we can directly modify the src/assets/css/main.css or define them in components.

Final Build and Run

desktop-app-wails

I really enjoyed working with Wails , and the Events concept makes it really easy to control your application's state.

Check it out at wails.app or on Github at github.com/wailsapp/wails

Full code for this article on GitHub

Top comments (6)

pic

Templates let you quickly answer FAQs or store snippets for re-use.

erielmejias99 profile image

  • Joined Mar 31, 2021

But you have to rebuild your Vue app to test... Another way??

waseemakhtar profile image

  • Location Greater Vancouver, Canada
  • Work Technical Solutions Architect
  • Joined May 16, 2019

Enjoyed knowing and reading

haruanm profile image

  • Joined Jan 1, 2018

Loved to know this framework.

donvitocodes profile image

  • Location Singapore
  • Work Looking for Remote Work
  • Joined Jan 16, 2019

Cool stuff! Just curious and for comparison, is there any similar project to this?

alyson profile image

  • Location Bangkok, Thailand
  • Joined Nov 19, 2017

consciousness_dev profile image

  • Joined Jul 12, 2018

I hope this project will go on...this brilliant...

Are you sure you want to hide this comment? It will become hidden in your post, but will still be visible via the comment's permalink .

Hide child comments as well

For further actions, you may consider blocking this person and/or reporting abuse

manavkush profile image

Learning Microservices with Go(Part 2). Service Discovery

Manav Kushwaha - Jan 30

vorillaz profile image

How to Automatically Consume RESTful APIs in Your Frontend

vorillaz - Jan 25

vivcis profile image

Creating a Bitcoin Address in Golang with btcd

ORJI CECILIA O. - Jan 30

dinckan_berat profile image

ESP32 to AWS: Complete IoT Solution with IoT Core, DynamoDB, and Lambda Functions in Golang

BERAT DİNÇKAN - Jan 29

Once suspended, plutov will not be able to comment or publish posts until their suspension is removed.

Once unsuspended, plutov will be able to comment and publish posts again.

Once unpublished, all posts by plutov will become hidden and only accessible to themselves.

If plutov is not suspended, they can still re-publish their posts from their dashboard.

Once unpublished, this post will become invisible to the public and only accessible to Alex Pliutau.

They can still re-publish the post if they are not suspended.

Thanks for keeping DEV Community safe. Here is what you can do to flag plutov:

plutov consistently posts content that violates DEV Community's code of conduct because it is harassing, offensive or spammy.

Unflagging plutov will restore default visibility to their posts.

DEV Community

We're a place where coders share, stay up-to-date and grow their careers.

  • All services
  • Product Strategy
  • Digital Transformation
  • Legacy app modernisation
  • Research & Development
  • Product Bootcamp
  • Enterprise app
  • Cloud Services
  • Team Augmentation
  • All technologies
  • React Native
  • Generative AI
  • Data science
  • Computer Vision
  • Machine Learning
  • All industries
  • Food delivery

Get to know us a little better and see what we’re all about

We’re always looking for fresh talent. Check how to join us

Learn more about our work and what we’ve been up to

Get valuable insights from our downloadable materials

Master important AI terms with our comprehensive dictionary

Leading industry experts discussing the future of tech

  • Software development

Top Golang apps: 10 best Golang applications

Top Golang Apps - 6 Best Apps Made With Golang

Fast and easy to use, the Golang programming language (also known as Go) is rapidly growing in popularity. According to Github stats , between 2018 and 2019 the Go community has grown by 147%. Golang attracts a lot of companies, as it was designed for complex enterprise projects. So, what exactly can you do with Golang and why are more and more companies choosing it over other languages?

In this article, we’re going to have a closer look at the top Golang applications . These real-life examples will help you see how this programming language can be the right choice for your businesses!

When to use Golang instead of other programming languages

There is no simple answer here. That’s why the choice really depends on your project’s individual requirements. However, it is worth mentioning that Golang is commonly used in some particular cases.

Distributed Network Services

Go’s concurrency capabilities and lightweight goroutines are a match made in heaven. If you’re building a complex system that handles multiple concurrent requests and ensures seamless communication between nodes, Go is a trusted ally. Its built-in support for concurrency and lightweight goroutines enables your services to juggle countless tasks efficiently.

Cloud-Native Development

In Cloud-Native development, Go is also a natural fit. Its simplicity and compact executables make it an excellent choice for building microservices that can be easily deployed and managed in a cloud environment. With Go, you can streamline your development process and embrace the cloud’s scalability and flexibility. 

Replacements for Existing Infrastructure

Golang’s ability to interact with low-level systems and its memory management capabilities make it ideal for building efficient replacements for legacy applications or infrastructure components. Go enables you to modernise your technology stack without sacrificing performance or stability. 

Media Platforms

Go is well-known for offering a robust and efficient solution. Its fast execution speed and built-in support for concurrent operations make it an excellent choice for handling real-time data processing, content delivery, and high-throughput services. 

Top 10 applications developed using Golang

Now that we have discussed the best Golang use cases, it is time to discover applications using this language in their development. Are you ready to dive into the fascinating world of Golang and explore some of the best apps crafted using this open-source programming language?

1. Banking app – Monzo

Most companies introduce Golang together with the microservices architecture. This was no different in the case of Monzo, an app-based online bank. When they first started setting up the application in February 2015, they were focused on the single responsibility principle. It states that every module should be responsible for a single functionality. This kind of approach makes the app more stable – and here’s where Go makes a great fit. Monzo is a classic example of an app built on Golang from the very start. 

Monzo - Golang banking app

As Monzo kept growing, Golang helped the company scale the product. The tech team states that Go is “perfect for microservice architectures”, as it helps them create granular services that add up to a stable app. 

Monzo consists of 1,600+ microservices. Matt Heath , the company’s senior engineer, claims that Go allows them to maintain such a complex architecture. In his words, the language is “quite simple […] and makes it easy […] to get people on board” . Indeed, Golang is famous for its low learning curve – some claim that developers can learn the basics within just one evening!

2. eCommerce app – Allegro

Allegro - Golang ecommerce app

In the case of Monzo, Go was the primary language since the very start. The Golang story was different for Allegro, a Polish ecommerce giant that has been around since 1999. Fast forward to 2016, the Allegro tech team was looking for an efficient way to create a very fast cache service. They decided to try something new and picked Golang for the task. 

Most of Allegro’s microservices are written in Java, yet the team was open to explore new things. They’ve worked with on an open-source Go project before and were happy to see how Golang will handle larger volumes of traffic. 

The final results were astonishing. Go helped Allegro speed up the application from 2.5 seconds to less than 250 milliseconds , and that’s for the longest request! The Allegro team swears by Golang and is happy to share their insights during Go-related conferences .

3. Music app – SoundCloud

SoundCloud - Golang music app

SoundCloud, an artist-focused music sharing platform, is quite an early adopter of Go. Of all the top Golang apps, SoundCloud, an artist-focused music sharing platform, is quite an early adopter. Back in 2012, they released an article about Go at SoundCloud . 

Although the app is largely based on Ruby on Rails, SoundCloud identifies as a polyglot company, with many languages adding up to their backend. They appreciate Golang as a WYSIWYG ( what you see is what you get ) language . This makes it easier for the entire team to understand the software and make the maintenance process more efficient.

What’s more, SoundCloud appreciates Golang’s fast compilation and static typing. In layman’s terms, this means that developing, testing, and deploying the application is as fast as possible. The team claims that these swift processes mean that some simple ideas can get from whiteboard to production in just one hour. Impressive, isn’t it?

4. Dating app – Badoo

Badoo - Golang dating app

Present in 190 countries and boasting 400 million users worldwide, Badoo is the world’s most widely used dating network. These numbers call for highly efficient search algorithms – and here’s where Golang comes in handy. 

To provide the smoothest search experience possible, the Badoo tech team creates services using bitmap indexes. A bitmap index is made of several bitmaps that represent entities (in this case, the users of the dating app) and their parameters (such as the age, or the hair color). This makes it the perfect fit for users who look for people with this , this , and not that – let’s say, men aged 25-30, blonde, taller than 180 cm. A match made in heaven for a dating app, isn’t it? 

Here’s the trick: bitmap indexes can be hard to implement in many popular database management systems, such as MySQL. The solution? You guessed it: Golang. Bitmap indexes are commonly used in Pilosa, a database management system written in Go. Without going too much into technical details, the Go language allows for smooth implementation of bitmap indexes, which is why the Badoo team decided to use it for their high-maintenance product. 

5. Ridesharing app – Uber

Yes, you’ve read that right – even Uber is using Golang to improve the quality of their ridesharing services. 

The company uses geofences for geolocation. A geofence defines an area with particular requirements. Most of the time, it applies to airports or especially busy neighbourhoods. Have a look at this geofence example from Kampala, Uganda:

Uber - Golang ridesharing app

Although Node.js was Uber’s first language of choice, they decided to start using Go for this service. The company needed something fast, as they’re dealing with hundreds of thousands of geofence lookup requests every second! Golang turned out to be the perfect pick, as it can work on multiple CPU cores at the same time, while Node.js is single-threaded. In other words, the Go language can do multiple things at once.

The choice proved to be largely successful and the Uber team is happy using Golang. Not only is it faster, but it also makes software developers more productive. When they’re already familiar with Java, C++, or Node.js, they will be able to learn Go in just a couple of days. 

When it comes to the app’s performance, the results are truly impressive. On New Year’s Eve 2015, Uber’s data center has successfully handled a peak load at just 35% CPU usage. To top it all off, the company can boast a whopping 99.99% uptime , with downtime caused only by third-party libraries and not Golang itself. 

Encouraged by the geofence success, Uber started implementing Golang in more of its microservices. For example, they’re using this language to match riders to the right drivers too. It has become their most popular language for creating new services within the product. It’s safe to say that Uber is one of the top Golang apps when it comes to popularity.

6. Project management app – Timesheets

Here’s one of the Golang applications that we’ve created. Timesheets is a time-tracking solution we’ve first used as an internal tool. As we’re really happy with it, we’ve decided to share Timesheets with the general public. The tool can be integrated with a range of other tools too, including Slack, Jira, or even voice assistants.

When creating Timesheets, Golang was our first choice. We wanted to create an ultra light, fast, and sufficient app and Golang’s multi-threading makes it much easier. What’s more, when we use common parts within one repository, we can run different processes simultaneously. To sum up, Golang speeds up the development process quite significantly.

7. Live-streaming app – Twitch

At the heart of Twitch’s infrastructure, Go plays a vital role, enabling the platform to handle the massive scale and real-time nature of its chat and messaging services. Go’s efficiency and concurrent processing capabilities allow Twitch to seamlessly process and deliver millions of chat messages in real time, keeping up with the fast-paced energy of live streaming events.

So, why Go? It’s simple, Golang is bringing incredible efficiency and the ability to handle a staggering amount of messages in real time. Go effortlessly keeps up with the fast-paced energy of live-streaming events.

But Go is more than just keeping things moving quickly. It also brings simplicity, making life easier for Twitch’s developers. The language’s straightforward syntax allows them to focus on what matters — building unique features that enhance the Twitch experience. 

8. Streaming app – Netflix

Behind the scenes, Netflix incorporates the power of Go into its development process, playing a crucial role in shaping the streaming app we all know.

Golang concurrency capabilities allow Netflix to handle multiple user requests simultaneously. It ensures your favourite shows start promptly, without annoying delays or buffering issues. 

But Go’s benefits continue beyond there. One of its standout features is simplicity. Netflix’s developers appreciate Go’s clean and intuitive syntax, which allows them to focus on writing clean code and building new features. 

So, the next time you dive into a show on Netflix, take a moment to appreciate the behind-the-scenes value that Go brings to the streaming world, making your viewing experience more enjoyable.

9. File-sharing app – Dropbox

Performance is crucial in the world of file storage, and Go also delivers on that front. Its built-in concurrency capabilities enable Dropbox to handle multiple user requests concurrently, ensuring speedy file operations. 

Dropbox also benefits from Go’s rich ecosystem of packages and libraries. This vast collection provides developers with a wide range of tools to optimise different aspects of the platform. 

Go plays a vital role in creating a reliable, elegant, and high-performing platform. Its reliability, simplicity, and performance characteristics make it the perfect companion for Dropbox’s mission of simplifying our digital lives.

10. Financial app – PayPal

Last but not least, this programming language brings its unique capabilities to the development of PayPal’s platform, making it a reliable and secure payment solution.

When it comes to performance, Go truly shines in PayPal’s development process. Its built-in concurrency capabilities enable PayPal to handle a high volume of transactions concurrently, ensuring speedy processing and minimal downtime. 

It is also worth mentioning that Go embodies a philosophy of simplicity and efficiency that resonates with PayPal’s development team. Its clean and concise syntax allows developers to write elegant code that focuses on delivering a seamless user experience. 

Furthermore, Go’s extensive standard library and thriving ecosystem of packages provide valuable tools and resources for PayPal’s developers. From encryption algorithms to network communication, Go offers a wealth of specialised packages that enhance the security and reliability of PayPal’s platform. 

How to handle Golang app development

Looking for a top Golang development company ? No matter what you’re planning to create,   we’re happy to share some advice. Our experience in developing apps with Go is sure to help. We hope that this roundup of apps made with Golang has left you inspired.

  • App development
  • Backend development

Your data is processed by Miquido sp. z o.o. sp.k. with its registered office in Kraków at Zabłocie 43A, 30 - 701 Kraków. The basis for processing your data is your consent and the legitimate interest of Miquido. You may withdraw your consent at any time by contacting us at [email protected] . You have the right to object, the right to access your data, the right to request rectification, deletion or restriction of data processing. For detailed information on the processing of your personal data, please see Privacy Policy . Show more

Related posts

desktop application written in golang

Node JS vs Golang – which one is best for you?

What is Golang programming language used for

What is Golang used for, and why should you choose it for your project?

desktop application written in golang

​Golang vs Java – which one is better for your next project?

  • Newsletters

Google’s Gemini is now in everything. Here’s how you can try it out.

Gmail, Docs, and more will now come with Gemini baked in. But Europeans will have to wait before they can download the app.

  • Will Douglas Heaven archive page

In the biggest mass-market AI launch yet, Google is rolling out Gemini , its family of large language models, across almost all its products, from Android to the iOS Google app to Gmail to Docs and more. You can also now get your hands on Gemini Ultra, the most powerful version of the model, for the first time.  

With this launch, Google is sunsetting Bard , the company's answer to ChatGPT. Bard, which has been powered by a version of Gemini since December, will now be known as Gemini too.  

ChatGPT , released by Microsoft-backed OpenAI just 14 months ago, changed people’s expectations of what computers could do. Google, which has been racing to catch up ever since, unveiled its Gemini family of models in December. They are multimodal large language models that can interact with you via voice, image, and text. Google claimed that its own benchmarking showed that Gemini could outperform OpenAI's multimodal model, GPT-4, on a range of standard tests. But the margins were slim. 

By baking Gemini into its ubiquitous products, Google is hoping to make up lost ground. “Every launch is big, but this one is the biggest yet,” Sissie Hsiao, Google vice president and general manager of Google Assistant and Bard (now Gemini), said in a press conference yesterday. “We think this is one of the most profound ways that we’re going to advance our company’s mission.”

But some will have to wait longer than others to play with Google’s new toys. The company has announced rollouts in the US and East Asia but said nothing about when the Android and iOS apps will come to the UK or the rest of Europe. This may be because the company is waiting for the EU’s new AI Act to be set in stone, says Dragoș Tudorache, a Romanian politician and member of the European Parliament, who was a key negotiator on the law.

“We’re working with local regulators to make sure that we’re abiding by local regime requirements before we can expand,” Hsiao said. “Rest assured, we are absolutely working on it and I hope we’ll be able to announce expansion very, very soon.”

How can you get it? Gemini Pro, Google’s middle-tier model that has been available via Bard since December, will continue to be available for free on the web at gemini.google.com (rather than bard.google.com). But now there is a mobile app as well.

If you have an Android device, you can either download the Gemini app or opt in to an upgrade in Google Assistant. This will let you call up Gemini in the same way that you use Google Assistant: by pressing the power button, swiping from the corner of the screen, or saying “Hey, Google!” iOS users can download the Google app, which will now include Gemini.

Gemini will pop up as an overlay on your screen, where you can ask it questions or give it instructions about whatever’s on your phone at the time, such as summarizing an article or generating a caption for a photo.  

Finally, Google is launching a paid-for service called Gemini Advanced. This comes bundled in a subscription costing $19.99 a month that the company is calling the Google One Premium AI Plan. It combines the perks of the existing Google One Premium Plan, such as 2TB of extra storage, with access to Google's most powerful model, Gemini Ultra, for the first time. This will compete with OpenAI’s paid-for service, ChatGPT Plus, which buys you access to the more powerful GPT-4 (rather than the default GPT-3.5) for $20 a month.

At some point soon (Google didn't say exactly when) this subscription will also unlock Gemini across Google’s Workspace apps like Docs, Sheets, and Slides, where it works as a smart assistant similar to the GPT-4-powered Copilot that Microsoft is trialing in Office 365.

When can you get it? The free Gemini app (powered by Gemini Pro) is available from today in English in the US. Starting next week, you’ll be able to access it across the Asia Pacific region in English and in Japanese and Korean. But there is no word on when the app will come to the UK, countries in the EU, or Switzerland.

Gemini Advanced (the paid-for service that gives access to Gemini Ultra) is available in English in more than 150 countries, including the UK and EU (but not France). Google says it is analyzing local requirements and fine-tuning Gemini for cultural nuance in different countries. But the company promises that more languages and regions are coming.

What can you do with it? Google says it has developed its Gemini products with the help of more than 100 testers and power users. At the press conference yesterday, Google execs outlined a handful of use cases, such as getting Gemini to help write a cover letter for a job application. “This can help you come across as more professional and increase your relevance to recruiters,” said Google’s vice president for product management, Kristina Behr.

Or you could take a picture of your flat tire and ask Gemini how to fix it. A more elaborate example involved Gemini managing a snack rota for the parents of kids on a soccer team. Gemini would come up with a schedule for who should bring snacks and when, help you email other parents, and then field their replies. In future versions, Gemini will be able to draw on data in your Google Drive that could help manage carpooling around game schedules, Behr said.   

But we should expect people to come up with a lot more uses themselves. “I’m really excited to see how people around the world are going to push the envelope on this AI,” Hsaio said.

Is it safe? Google has been working hard to make sure its products are safe to use. But no amount of testing can anticipate all the ways that tech will get used and misused once it is released. In the last few months, Meta saw people use its image-making app to produce pictures of Mickey Mouse with guns and SpongeBob SquarePants flying a jet into two towers. Others used Microsoft’s image-making software to create fake pornographic images of Taylor Swift .

The AI Act aims to mitigate some—but not all—of these problems. For example, it requires the makers of powerful AI like Gemini to build in safeguards, such as watermarking for generated images and steps to avoid reproducing copyrighted material. Google says that all images generated by its products will include its SynthID watermarks. 

Like most companies, Google was knocked onto the back foot when ChatGPT arrived. Microsoft’s partnership with OpenAI has given it a boost over its old rival. But with Gemini, Google has come back strong: this is the slickest packaging of this generation’s tech yet. 

Artificial intelligence

Ai for everything: 10 breakthrough technologies 2024.

Generative AI tools like ChatGPT reached mass adoption in record time, and reset the course of an entire industry.

What’s next for AI in 2024

Our writers look at the four hot trends to watch out for this year

  • Melissa Heikkilä archive page

These six questions will dictate the future of generative AI

Generative AI took the world by storm in 2023. Its future—and ours—will be shaped by what we do next.

OpenAI teases an amazing new generative video model called Sora

The firm is sharing Sora with a small group of safety testers but the rest of us will have to wait to learn more.

Stay connected

Get the latest updates from mit technology review.

Discover special offers, top stories, upcoming events, and more.

Thank you for submitting your email!

It looks like something went wrong.

We’re having trouble saving your preferences. Try refreshing this page and updating them one more time. If you continue to get this message, reach out to us at [email protected] with a list of newsletters you’d like to receive.

  • Search for: Toggle Search

Say What? Chat With RTX Brings Custom Chatbot to NVIDIA RTX AI PCs

Chatbots are used by millions of people around the world every day, powered by NVIDIA GPU-based cloud servers. Now, these groundbreaking tools are coming to Windows PCs powered by NVIDIA RTX for local, fast, custom generative AI .

Chat with RTX , now free to download , is a tech demo that lets users personalize a chatbot with their own content, accelerated by a local NVIDIA GeForce RTX 30 Series GPU or higher with at least 8GB of video random access memory, or VRAM.

Ask Me Anything

Chat with RTX uses retrieval-augmented generation (RAG), NVIDIA TensorRT-LLM software and NVIDIA RTX acceleration to bring generative AI capabilities to local, GeForce-powered Windows PCs. Users can quickly, easily connect local files on a PC as a dataset to an open-source large language model like Mistral or Llama 2, enabling queries for quick, contextually relevant answers.

Rather than searching through notes or saved content, users can simply type queries. For example, one could ask, “What was the restaurant my partner recommended while in Las Vegas?” and Chat with RTX will scan local files the user points it to and provide the answer with context.

The tool supports various file formats, including .txt, .pdf, .doc/.docx and .xml. Point the application at the folder containing these files, and the tool will load them into its library in just seconds.

Users can also include information from YouTube videos and playlists. Adding a video URL to Chat with RTX allows users to integrate this knowledge into their chatbot for contextual queries. For example, ask for travel recommendations based on content from favorite influencer videos, or get quick tutorials and how-tos based on top educational resources.

desktop application written in golang

Since Chat with RTX runs locally on Windows RTX PCs and workstations, the provided results are fast — and the user’s data stays on the device. Rather than relying on cloud-based LLM services, Chat with RTX lets users process sensitive data on a local PC without the need to share it with a third party or have an internet connection.

In addition to a GeForce RTX 30 Series GPU or higher with a minimum 8GB of VRAM, Chat with RTX requires Windows 10 or 11, and the latest NVIDIA GPU drivers.

Editor’s note: We have identified an issue in Chat with RTX that causes installation to fail when the user selects a different installation directory. This will be fixed in a future release. For the time being, users should use the default installation directory (“C:\Users\<username>\AppData\Local\NVIDIA\ChatWithRTX”).

Develop LLM-Based Applications With RTX

Chat with RTX shows the potential of accelerating LLMs with RTX GPUs. The app is built from the TensorRT-LLM RAG developer reference project, available on GitHub . Developers can use the reference project to develop and deploy their own RAG-based applications for RTX, accelerated by TensorRT-LLM. Learn more about building LLM-based applications .

Enter a generative AI-powered Windows app or plug-in to the NVIDIA Generative AI on NVIDIA RTX developer contest, running through Friday, Feb. 23, for a chance to win prizes such as a GeForce RTX 4090 GPU, a full, in-person conference pass to NVIDIA GTC and more.

Learn more about Chat with RTX .

NVIDIA websites use cookies to deliver and improve the website experience. See our cookie policy for further details on how we use cookies and how to change your cookie settings.

How to remotely access a computer and fix your family’s IT problems for free

Controlling a computer from across the country can be a lot easier than you may think..

desktop application written in golang

Maybe a friend’s printer is on the fritz. Or your parents are wondering why their computer is running slower than usual.

These mundane tech issues happen all the time, and I’d be willing to bet you’ve had to troubleshoot one — or asked someone to help you — at least once. But what happens when the people in your life who need hands-on help live too far away for a drop-in?

As it turns out, you may already have access to tools that can help you take control of someone else's computer and fix those problems from afar. Even better, they're free, and a lot easier to use than you might think.

But, as a famous fictional uncle once said, “with great power comes great responsibility.” Once the people in your life find out you can fix some of their computer problems from the comfort of your couch, you may soon find yourself up to your eyeballs in tech support requests. Our advice? Use this power wisely, and maybe set some boundaries.

Things to keep in mind

This may go without saying but the people on both sides of this equation have to be connected to the internet. If the person you’re trying to help remotely doesn’t have an internet connection, you could try walking them through tethering to a compatible iPhone or Android smartphone , if their cellular plan allows for it.

And because the tools we’re going to discuss essentially give you a live video feed of someone else’s computer over the internet, don’t be surprised by the occasional hiccup or bit of lag either — it just happens sometimes.

For Windows PCs

What you need:

  • Two computers running either Windows 10 or 11. (If you regularly use an older version of Windows, we’d strongly recommend you update at some point. Microsoft ended support for Windows 8.1 in January 2023.
  • A Microsoft account (for the person trying to assist someone else)

Getting started:

  • Find and run the Quick Assist app. (The easiest way to do this is type “Quick Assist” into the search bar; you may also have to update the app via the Microsoft Store if you’ve never used it.)
  • Click the “Assist another person” button under the “Give assistance” header, and log into your Microsoft account.
  • Once you’re logged in, you’ll be given a six character code that you’ll share with whomever you’re trying to help. Have them open the Quick Assist app on their end and plug in the code before the 10-minute time limit expires.
  • If you want supervise the person on the other end while they try to work through things themselves, select the “View screen” option. But if you’d rather just do it all yourself, select the “Take full control” option.
  • At this point, the person you’re trying to help has to grant their permission. Once they hit the “Accept” button, you’ll be able to see — and control — their PC.

From here, you can dive right into their computer and make whatever changes you both decide are helpful or needed.

Like Windows, Apple’s Mac computers come with a competent — and free — built-in screen sharing tool. So what’s the catch?

Well, for one, it’s a little tricky to find. You won’t see it in your Mac’s Launchpad or Applications folder. The best way to access it is to open the Spotlight search bar by pressing the Command key and the space bar at the same time, then typing in “Screen sharing.”

Once you’ve successfully launched the app, you’ll need either the remote machine’s host name (which no one ever remembers) or the Apple ID tied to that machine.

Thankfully, there’s an easier way to start using this tool.

  • Two Mac computers running MacOS High Sierra or newer.
  • Apple IDs for both computers.
  • Start — or continue — a conversation in the built-in Messages app with the person whose computer you want to control.
  • Click the icon in the top-right corner that looks like an “i” inside a circle.
  • Click the “share” button, followed by “Ask to Share Screen.”
  • The person on the other end will get a prompt asking them to share their screen. Once they accept your request, they can choose whether to give you full control over their computer — so you can make changes directly — or to just let you observe.

For cross-platform fixes

Maybe you’re a Windows fan, but everyone else you know has a Mac — or vice versa. It’s OK: You can still remotely help out with their computer problems; you just need to look elsewhere for the right tools.

We’ve had the best luck with TeamViewer Remote , a service that’s totally free for personal use. You’ll need to create an account with the company, but once that’s done, a few clicks is all it takes to create a new remote “session” — complete with a link you can send to the person who needs help.

Once they click that link, they’ll be directed to install the TeamViewer client app — if they’re on a Mac, they’ll have to make a few quick changes in System Settings the TeamViewer app can guide them through. After that, they get one last prompt to join the session, and voilà: You’re controlling their computer for them, right from a web browser.

Help Desk: Making tech work for you

Help Desk is a destination built for readers looking to better understand and take control of the technology used in everyday life.

Take control: Sign up for The Tech Friend newsletter to get straight talk and advice on how to make your tech a force for good.

Tech tips to make your life easier: 10 tips and tricks to customize iOS 16 | 5 tips to make your gadget batteries last longer | How to get back control of a hacked social media account | How to avoid falling for and spreading misinformation online

Data and Privacy: A guide to every privacy setting you should change now . We have gone through the settings for the most popular (and problematic) services to give you recommendations. Google | Amazon | Facebook | Venmo | Apple | Android

Ask a question: Send the Help Desk your personal technology questions .

  • Workout content is taking over social media. Here’s how to banish it. March 15, 2023 Workout content is taking over social media. Here’s how to banish it. March 15, 2023
  • Want to drink less in 2023? These habit-tracking apps can help. December 21, 2022 Want to drink less in 2023? These habit-tracking apps can help. December 21, 2022
  • The long, lonely wait to recover a hacked Facebook account November 21, 2022 The long, lonely wait to recover a hacked Facebook account November 21, 2022

desktop application written in golang

IMAGES

  1. GitHub

    desktop application written in golang

  2. What is Golang Used For? 7 Examples of Go Applications

    desktop application written in golang

  3. gui

    desktop application written in golang

  4. What is Golang and How to Install It

    desktop application written in golang

  5. Golang Web Application

    desktop application written in golang

  6. What is Go? Golang Programming Language Meaning Explained

    desktop application written in golang

VIDEO

  1. Golang Net/Http Tutorial Part 1

  2. Deploying Golang app on Azure Container App

  3. The Start Of A New Web Framework In Golang

  4. GTK3 with Golang

  5. GTK3 with Golang

  6. Live Reload With Golang

COMMENTS

  1. GitHub

    Desktop applications with GO ♥ One codebase for Gnu/Linux, macOS, and Windows. UI Hot Reload. You can use any front end framework. Supports Chrome, and native webview engine or both. Windows MSI bundler builtin. 📜 Installation 1. Install guark CLI tool: go install github.com/guark/guark/cmd/guark@latest 2. Some Requirements:

  2. Learning Go by examples: part 7

    Golang is used a lot for CLI and microservices but what about creating a GUI/Desktop and a mobile application? Initialization We created our Git repository in the previous article, so now we just have to retrieve it locally: $ git clone https://github.com/scraly/learning-go-by-examples.git $ cd learning-go-by-examples

  3. Best GUI frameworks for Go

    GTK (GIMP Toolkit) is a multi-platform toolkit for building GUIs. GTK is written in C and has bindings for various programming languages, including C++, Python, C#, and Go. GTK3 helps create desktop applications for Linux and Unix-like systems and supports macOS.

  4. How to Create a Simple Desktop App with Golang and Fyne

    · Mar 15, 2022 -- 1 In this article, I will go over a little project that I made to explore some of the possibilities of the Fyne GUI toolkit. This collection of packages implements desktop GUI functionality for Golang on multiple platforms. I chose to create a data-entry app for this project since this seems to be very useful for many people.

  5. GitHub

    Depends on your requirements. It's designed to make it easy for Go programmers to make lightweight desktop applications or add a frontend to their existing applications. Wails does offer native elements such as menus and dialogs, so it could be considered a lightweight electron alternative.

  6. Creating Cross-Platform Desktop Applications with Go

    Performance: Go's compiled nature ensures that applications written in Go perform exceptionally well, making it suitable for resource-intensive desktop applications. Concurrency: Go's built-in support for concurrency and goroutines enables developers to create responsive desktop applications that handle multiple tasks concurrently.

  7. Build a cross-platform desktop application with Go and Wails

    Bash. wails init -n github_demo -t react. Copy. This scaffolds a new project using Go for the backend and React + Vite for the frontend. Once the scaffolding process is completed, navigate into the newly created folder and run the project, by running the commands below. Bash. cd github_demo wails dev. Copy.

  8. Building modern desktop apps in Go

    by Serge ZaitsevAt: FOSDEM 2019https://video.fosdem.org/2019/UD2.120/godesktopapps.webmI'll show how to quickly build a simple desktop app with Go+HTML5, tha...

  9. Build a Desktop App in Go Using Wails and React

    All application-related details for versioning reside in the wails.json file, and our backend functionality code can be found inside the appropriately named app.go. Configuration of window sizing and other platform-related settings are all declared inside of main.go, which acts as the main entry point of our app:

  10. How To Create A CRUD Desktop App With Golang, Fyne and MongoDB

    Apr 30, 2022 -- Photo by Leif Christoph Gottwald on Unsplash In this article, I will show you how to create a small desktop app in which you can enter, view, update and delete contact information. I will program this app in the Go language (Golang) and use the Fyne GUI toolkit to create the user interface.

  11. Build a Desktop App with Go and HTML5

    In this tutorial, you'll learn how to build a simple Desktop App with Go and HTML5A Guide to Golang E-Commerce☞ https://morioh.com/p/3d1f6febc8b4Learn Go Pro...

  12. Fyne (Golang) desktop app with goroutines

    One example of viable use case for Golang desktop app would be to quickly add graphical interface for existing CLI app. And Fyne is great framework for that purpose. As stated on their official GitHub page, it's 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 ...

  13. GUI

    gio - Gio is a library for writing cross-platform immediate mode GUI-s in Go. Gio supports all the major platforms: Linux, macOS, Windows, Android, iOS, FreeBSD, OpenBSD and WebAssembly. go-astilectron - Build cross platform GUI apps with GO and HTML/JS/CSS (powered by Electron). go-gtk - Go bindings for GTK. go-sciter - Go bindings for Sciter ...

  14. Building Cross Platform Desktop apps with Golang

    Golang, known for its simplicity and efficiency, is an excellent choice for developing cross-platform desktop applications. In this article, we will explore Fyne, a modern and easy-to-use GUI...

  15. GUI

    The most common are web-based and desktop-based. Many apps are going in the web-based direction, think Google apps or Cloud apps. One advantage of this is that apps will work on many different operating systems (Mac, Windows). Which package is best depends on your needs. Web based Go GUI App. The app package can create apps with GO, HTML and CSS.

  16. Golang Desktop App: Webview vs. Lorca vs. Electron

    Maori Geek · 5 min read · Aug 6, 2020 -- 6 I want to build a local desktop Golang app, there are a few ways to do this: Electron: bundled Node.js and the Chromium browser to create a packaged local web-app. Usable with Golang frameworks like go-app or go-astilectron.

  17. Writing GUIs in Golang

    Web Server Method In this method, you'll have your program start a web server using net/http and use HTML, CSS, and text/template to create a user interface (essentially a website). The Go application can then interact with the website UI using WebSockets or through ajax requests.

  18. Building a Desktop App in Go using Wails

    This post is a text version of packagemain #6: Building Desktop App in Go using Wails video. As we all know, Go is mostly used to build APIs, web backends, CLI tools. But what's interesting is ...

  19. Building Desktop App in Go using Wails

    This post is a text version of packagemain #6: Building Desktop App in Go using Wails video. As we all know, Go is mostly used to build APIs, web backends, CLI tools. But what's interesting is that Go can be used in places we were not expecting to see it. For example, we can build a Desktop App with Go and Vue.js using Wails framework.

  20. Golang Tutorial

    225 Share 4.4K views 1 year ago #golang #easy #desktop In this video, you will learn how to create an application desktop using Golang and WebView. If you like this video, support me with...

  21. Best Golang Applications: 10 Companies Using the Go Language

    Top 10 applications developed using Golang Now that we have discussed the best Golang use cases, it is time to discover applications using this language in their development. Are you ready to dive into the fascinating world of Golang and explore some of the best apps crafted using this open-source programming language? 1. Banking app - Monzo

  22. Building a Desktop UI in Go

    Building a Desktop UI in Go Is it a good idea? Divan Visagie · Follow Published in From The Couch · 5 min read · Sep 21, 2017 -- 4 This story now has a permanent home on my website I started my...

  23. How does golang fare in desktop applications? : r/golang

    There are also few specific tricks when building desktop GUI for Windows: Embedding icons into binary done via rsrc tool available on github. Building using "go build -ldflags="-H windowsgui" because you do not want command prompt open when app is launched. Redirecting log into a file.

  24. New macOS Backdoor Written in Rust Shows Possible Link ...

    The files' source code is written in Rust, and analysis of the binaries reveals the names of the original source files. Rust's syntax and semantics differ from those of more common languages like C or Python, making it harder for security researchers to analyze and detect malicious code.

  25. Google's Gemini is now in everything. Here's how you can try it out

    At the press conference yesterday, Google execs outlined a handful of use cases, such as getting Gemini to help write a cover letter for a job application. "This can help you come across as more ...

  26. Business customer guide: End of Life (EOL) for use of Authy API with

    For users implementing the Authy APIs to secure your application(s), we would like to recommend you the following: Prepare communication around this notice and related timelines to your internal teams and your customers to minimize surprise or panic on the part of your customers.

  27. Chat with RTX Now Free to Download

    Chatbots are used by millions of people around the world every day, powered by NVIDIA GPU-based cloud servers. Now, these groundbreaking tools are coming to Windows PCs powered by NVIDIA RTX for local, fast, custom generative AI.. Chat with RTX, now free to download, is a tech demo that lets users personalize a chatbot with their own content, accelerated by a local NVIDIA GeForce RTX 30 Series ...

  28. The best free remote desktop software to access a computer remotely

    Start — or continue — a conversation in the built-in Messages app with the person whose computer you want to control. Click the icon in the top-right corner that looks like an "i" inside a ...