Are Desktop Applications Dead?
As modern development continues to hurtle at the speed of light towards exciting possibilities — including web services and mobile applications that can be easily accessed from your pocket — unfortunately, in this hectic race, we often forget about the proven platforms that are already a standard in a number of industries. That said, many professionals still see lightweight desktop applications as the best tools to go about their daily business and do not share the belief that a web interface cosplaying as a desktop application can provide the same levels of comfort as a classic native desktop app.
So with this in mind, at SPG, we believe that desktop applications are far from extinct, and there are a multitude of cases today where you could choose to employ a desktop app. More importantly, however, by using the cross-platform Gio software library, you can build exceptional user interfaces — for both desktop and mobile devices.
What Is the Right Technology for Desktop Applications?
If you’re familiar with modern technologies for desktop development, you probably know that Java, .NET and C++/Qt are the most popular options, so let’s examine them a little closer.
When it comes to .NET and Java, these are undeniably the dominant technologies. This means that they are extremely reliable, are widely supported across a number of different platforms and in the vast majority of cases, will likely be your safest bet. On the other hand, if you are developing a high-performance application (e.g. an interactive interface loading vast amounts of data), they may no longer be the best technologies and you might be better paired with a more optimised alternative.
On that note, while C++ combined with the Qt framework has the advantage of being a native technology and thus provides you with improved performance, it will invariably require a lot more effort (read: cost more money in both development and support), as there are fewer specialists on the market, particularly when compared to .NET and Java.
Consequently, it stands to reason that the current state of desktop development is in reality far from ideal, as you are often forced to decide between development costs and application performance. The obvious solution here would be to opt for a software technology requiring low development effort to build a high-performance desktop application, and this is where the Go language springs immediately to mind. Though until very recently, a major difficulty was the lack of GUI app support, this problem has been solved by Elias Naur — the creator of the Gio UI library.
Let’s GO! — an Alternative for Creating Desktop Applications
Google “what can I do with Golang?” and you will find that Go supports console or text-based applications and is fantastic for system programming, CI/CD and distributed programs, but there is a lot more to Golang than meets the eye. Take Gio UI, for instance, the groundbreaking Golang UI framework enabling developers to use the popular Go language to build fast-performing GUI interfaces for all major platforms. This makes it perfect for cross-platform application development (Windows, MacOS, Linux, mobile and web). The tool is native, lightweight and can build executable files with no dependencies.
Gio is also an open-source library that offers a small set of widgets which are compliant with Material Design principles. Essentially, therefore, it is a Golang UI library for implementing immediate mode graphics.
Take a look at the examples below to see the power of Gio UI in action!
At SPG, we believe that Gio UI is an excellent candidate for building lightweight desktop applications with an emphasis on platform-agnostic GUI application development. After all, when it comes to mobile development, not only is its architecture based on the same principle as the Google Flutter framework, but similarly to Flutter, it also utilises components and layouts.
Under the hood, the library likewise leaves nothing to be desired, as Gio has been designed as a complete stack of operations and modules for every one of its supported platforms. As a result, its operations will always be rendered using native canvases.
Furthermore, every component is given the appropriate context for drawing and will return the size of the rendered component:
func (c *Component) Layout(gtx layout.Context) layout.Dimensions {} As you can see from the Layout method displayed above, each component may include specific visualisation logic. In addition, they have their own persistent state and customisation (i.e. style).
Another interesting feature to note is that when a component is implemented, you can visualise it using different sets of layouts. For instance, if you would like to flip your components horizontally, you can simply use
layout.Flex{Axis: layout.Horizontal}.Layout(gtx,
layout.Rigid(component1.Layout),
layout.Rigid(component2.Layout)) Without a doubt, Gio UI is the full desktop package, as it is perfect for cross-platform desktop applications, and supports the following GUI operations:
- Mouse and keyboard events
- 2D drawing & transformations
- Clipping drawing areas
Gio also supports working with a system clipboard and features basic GUI components and component layouts.
The (Go)Lang and Short of It
At the moment, Gio UI is a brand new library with growing support and development interest. This means that in order to utilise it to its full potential, you need an expert with a proven record.
Luckily, at SPG, our developers use our own private fork of the Gio UI library that not only adds important features but supports complex GUI applications. This includes lightweight desktop applications with overlapping windows and popups as well as simple drag-and-drop operations. These features were successfully tested in our trading terminal project, which is described in a previous article.
If you plan to quickly build your GUI application, Software Planet Group will be happy to support you in this project using Go and the Gio UI library or whichever technology best meets your needs.
