Forem: energy

A New Era of Cross-Platform Desktop Application Development in Go Language: A Comprehensive Analysis of LCL, CEF, and Webview

energy — Mon, 18 Nov 2024 03:30:06 +0000

Opening Words

In the vast ecosystem of Go language, desktop application development has always been a field of great attention. Today, I will introduce three cross-platform desktop application development frameworks based on the Go language—LCL, CEF, and Webview. Each of them possesses unique charm and broad application scenarios. Through these three frameworks, you will be able to easily develop powerful and aesthetically pleasing cross-platform desktop applications.

1. LCL: The Native Component Treasury in Go Language

Open Source Address: https://github.com/energye/lcl

Introduction:

LCL (Lazarus Component Library) is a lightweight, small-sized cross-platform desktop application development framework under the Go language. It provides about 200 system-native components, making it easy for developers to build interfaces that conform to the style of different operating systems. Whether it's the Windows, Mac OS, or Linux platform, LCL can offer you rich native component support.

Features:

Lightweight and small in size, easy to integrate and deploy.
Rich component library to meet various development needs.
One set of code, run across platforms, reducing development costs.
Construction & Usage: LCL can be used independently or mixed with other frameworks. When used independently, you can develop pure native graphical user interface (GUI) applications; when mixed with other frameworks, you can combine their respective advantages to create more complex and powerful desktop applications.

2. CEF: The Magic Tool for Web Technology Integration in Go Language

Open Source Address: https://github.com/energye/cef

Introduction:

Go CEF is a framework developed under the Go language based on LCL and CEF (Chromium Embedded Framework). It combines the native component library of LCL and the browser component library of CEF, enabling developers to use Go language and web-end technologies (HTML+CSS+JavaScript) to build desktop applications that support the Windows platform. CEF4Delphi encapsulates the CEF3 library on the basis of LCL, providing strong browser support for Go CEF.

Features:

Depends on the CEF binary framework environment, providing complete CEF API.
Possesses both the system-native components of LCL and the browser components of CEF, offering rich functionalities.
Simple development environment, fast compilation speed, enhancing development efficiency.
Supports mainstream front-end frameworks (Vue, React, Angular, etc.), lowering the threshold for front-end technology.
High-performance event-driven and IPC communication, achieving rapid invocation and data interaction between Go and the web end.
Construction & Usage: Go CEF supports the mixed use of LCL and CEF. You can use LCL's native components to construct the main interface of the application while utilizing CEF's browser components to embed web content. This hybrid usage method gives Go CEF unique advantages in cross-platform desktop application development.

3. Webview: The Lightweight Web Content Integration Expert in Go Language

Open Source Address: https://github.com/energye/wv

Introduction:

Go Webview (wv) is a framework developed under the Go language based on LCL and WebView technology. It supports browser component libraries such as Windows-Webview2, Linux-Webkit2, and MacOS-Webkit2, allowing developers to use Go language and web-end technologies to build cross-platform desktop applications. WebView4Delphi, Webkit2GTK, and Webkit2Cocoa respectively encapsulate corresponding WebView libraries on the basis of LCL, providing strong browser support for Go Webview.

Features:

Lightweight, easy to integrate and deploy.
Supports full WebView2 and Webkit2 APIs, powerful functions.
Does not require HTTP service support, can directly read local resources or resources embedded in the executable file.
Supports mainstream front-end frameworks and native HTML+CSS+JS technologies, reducing development difficulty.
High-performance event-driven and custom content interaction, meeting the needs of various application scenarios.
Construction & Usage: Go Webview also supports the mixed use of LCL and WebView. You can use LCL's native components to construct the main interface of the application while using WebView to embed web content. This lightweight yet powerful method gives Go Webview broad prospects for application in cross-platform desktop application development.

Through this introduction, I believe everyone now has a deeper understanding of the three cross-platform desktop application development frameworks under the Go language—LCL, CEF, and Webview. Each has its own unique charm and broad application scenarios. Whether you need to develop a desktop application with rich native components or seamlessly integrate web content into your application, you can find suitable solutions among these three frameworks.

Example Address: https://github.com/energye/examples

Now, let us take action together and use these powerful frameworks to create even better and more practical cross-platform desktop applications! Don't forget to follow my blog to get more exciting content about Go language and cross-platform desktop application development.

Creating desktop applications in Golang

energy — Sun, 11 Jun 2023 09:37:20 +0000


package main

import (
    "embed"
    "fmt"
    "github.com/energye/energy/v2/cef"
    "github.com/energye/energy/v2/cef/ipc"
    "github.com/energye/energy/v2/cef/ipc/context"
    "github.com/energye/energy/v2/common"
    "github.com/energye/energy/v2/pkgs/assetserve"
    "github.com/energye/golcl/lcl/rtl/version"
)

//go:embed resources
var resources embed.FS

func main() {
    cef.GlobalInit(nil, &resources)
    cefApp := cef.NewApplication()
    cef.BrowserWindow.Config.Url = "http://localhost:22022/index.html"
    if common.IsLinux() {
        cef.BrowserWindow.Config.IconFS = "resources/icon.png"
    } else {
        cef.BrowserWindow.Config.IconFS = "resources/icon.ico"
    }
    if !common.IsDarwin() { 
        cef.BrowserWindow.Config.EnableHideCaption = true
    }
    cef.BrowserWindow.Config.Title = "Energy Vue + ElementUI Demo"
    cef.BrowserWindow.Config.Width = 1200
    chromiumConfig := cef.BrowserWindow.Config.ChromiumConfig()
    chromiumConfig.SetEnableMenu(false)

    ipc.On("window-state", func(context context.IContext) {
        bw := cef.BrowserWindow.GetWindowInfo(context.BrowserId())
        state := context.ArgumentList().GetIntByIndex(0)
        if state == 0 {
            bw.Minimize()
        } else if state == 1 {
            bw.Maximize()
        }
    })
    ipc.On("window-close", func(context context.IContext) {
        bw := cef.BrowserWindow.GetWindowInfo(context.BrowserId())
        bw.CloseBrowserWindow()
    })
    ipc.On("os-info", func(context context.IContext) {version.OSVersion.ToString())
        context.Result(version.OSVersion.ToString())
    })

    cef.BrowserWindow.SetBrowserInit(func(event *cef.BrowserEvent, window cef.IBrowserWindow) {
        //
    })
    cef.SetBrowserProcessStartAfterCallback(func(b bool) {
        server := assetserve.NewAssetsHttpServer()
        server.PORT = 22022               
        server.AssetsFSName = "resources" 
        server.Assets = &resources
        go server.StartHttpServer()
    })
    cef.Run(cefApp)
}

Building cross platform desktop applications using JavaScript, HTML, and CSS in GO

energy — Thu, 08 Jun 2023 06:04:36 +0000

Energy is the framework for Go to build desktop applications based on CEF

Github

Gitee

Project Introduction

Energy is a framework developed by Golang based on CEF(Chromium Embedded Framework), embedded with CEF binary
Use Go and Web technology (HTML+CSS+JavaScript) to build cross-platform desktop applications that support Windows, Linux and MacOS
Knowledge of the front-end technology stack and some knowledge of the Go language is required

Characteristic

development environment is simple and the compilation speed is fast. Only the Go development environment and the CEF binary framework that Energy depends on are needed
cross-platform: A set of code can be packaged into Windows, domestic UOS, Deepin, Kylin, MacOS, Linux
Language responsibilities
Go: Go is responsible for window creation, CEF configuration and function implementation, creation of various UI components, low-level system calls, and functions that JS cannot handle, such as file stream, security encryption, high-performance processing, etc., which can be developed as a pure backend
Web: HTML + CSS + JavaScript responsible for the function of the client interface, make any interface you want, can be used as a pure front-end development
front-end technology: Support mainstream front-end frameworks, such as Vue, React, Angular or pure HTML+CSS
event driven: High performance event driven, IPC based communication, Go and Web side is very convenient function call and data interaction

Go interacts with the Web

The Go and Web technologies are based on IPC communication. Data and event triggering can be exchanged between Go and Web without using the http interface, which is as simple as calling the functions of the language itself
Define JS binding type variables in Go and provide them to JS on the Web side to realize data synchronization of Go variables or structural objects
Listen for events in JS and trigger JS events in Go to achieve Go calling JS functions and passing parameter
Listen for events in Go and trigger Go events in JS to achieve JS calling Go functions and passing parameters

Built-in dependency&integration

Golcl
CEF

Development environment

Install automatically using the energy command line tool

Basic needs

golang >= 1.18

energy development environment

Use the energy command line tool to automatically install the development environment

Get energy project, or use the precompiled command line tool directly Download address

go get github.com/energye/energy
Enter the energy command line directory

cd energy/cmd/energy
Install command line tools

go install
Execute the installation command

energy install .

example/simple Code

package main

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

func main() {
    //Global initialization must be called by every application
    cef.GlobalInit(nil, nil)
    //Create application
    cefApp := cef.NewApplication()
    //Set URL
    cef.BrowserWindow.Config.Url = "https://energy.yanghy.cn"
    //Run App
    cef.Run(cefApp)
}

System support

windows - 32, 64
linux, linux-arm - 64
mac 64

Exchange QQ Group

541258627

email

snxamdf@126.com

Public License

Apache-LICENSE-2.0