2017-04-07 00:22:01 +03:00
Introduction
2018-03-20 16:52:35 +03:00
------------
2017-04-07 00:22:01 +03:00
initial commit of the interop engine + new flutter module + fixes for minor issues
this commit introduces the new experimental `interop` module, which is used to allow the use of `therecipe/qt` from languages other than go or javascript.
as a start, there was support for the dart language added (currently only in combination with a custom flutter embedder engine, but plain dart support should follow soon).
the interop module makes great use of the qml/js interop functions and logic that were written to make `https://github.com/therecipe/entry` possible.
additional languages that are planned to be supported in the near future are: swift, kotlin and haxe (maybe with support for the c#, python and java targets, but if this isn't possible in some clean way then these languages will receive standalone bindings as well).
people using `therecipe/qt` from these new languages should then be able to use flutter (and dart) in combination with qt (and go/js) through this binding and also be able to easily communicate across the language barriers with the help of the interop functions.
the interop engine theoretically also makes a cgo-less `therecipe/qt` usage possible, which could be used to workaround the ever growing annoyances that are experienced when using cgo projects in combination with go modules.
the code for the custom flutter embedder that was created to make the flutter/dart binding work can be found in the `flutter` module. it currently only supports debug builds for the desktop targets, but if there is enough interest, then it shouldn't be too difficult to make release builds there, and on the mobile targets work as well (or even on "embedded" systems such as an raspberry pi for that matter).
an example repo how to use the new flutter/dart binding, will be published in the next few days.
2020-06-01 22:27:56 +03:00
[Qt ](https://en.wikipedia.org/wiki/Qt_(software )) is a free and open-source widget toolkit for creating graphical user interfaces as well as cross-platform applications that run on various software and hardware platforms with little or no change in the underlying codebase.
2017-04-07 00:22:01 +03:00
initial commit of the interop engine + new flutter module + fixes for minor issues
this commit introduces the new experimental `interop` module, which is used to allow the use of `therecipe/qt` from languages other than go or javascript.
as a start, there was support for the dart language added (currently only in combination with a custom flutter embedder engine, but plain dart support should follow soon).
the interop module makes great use of the qml/js interop functions and logic that were written to make `https://github.com/therecipe/entry` possible.
additional languages that are planned to be supported in the near future are: swift, kotlin and haxe (maybe with support for the c#, python and java targets, but if this isn't possible in some clean way then these languages will receive standalone bindings as well).
people using `therecipe/qt` from these new languages should then be able to use flutter (and dart) in combination with qt (and go/js) through this binding and also be able to easily communicate across the language barriers with the help of the interop functions.
the interop engine theoretically also makes a cgo-less `therecipe/qt` usage possible, which could be used to workaround the ever growing annoyances that are experienced when using cgo projects in combination with go modules.
the code for the custom flutter embedder that was created to make the flutter/dart binding work can be found in the `flutter` module. it currently only supports debug builds for the desktop targets, but if there is enough interest, then it shouldn't be too difficult to make release builds there, and on the mobile targets work as well (or even on "embedded" systems such as an raspberry pi for that matter).
an example repo how to use the new flutter/dart binding, will be published in the next few days.
2020-06-01 22:27:56 +03:00
[Go ](https://en.wikipedia.org/wiki/Go_(programming_language )), also known as Golang, is a programming language designed at Google.
2017-04-07 00:22:01 +03:00
2020-08-17 19:37:48 +03:00
[therecipe/qt ](https://github.com/therecipe/qt ) allows you to write Qt applications entirely in Go, [JavaScript/TypeScript ](https://github.com/therecipe/entry ), [Dart/Flutter ](https://github.com/therecipe/flutter ), [Haxe ](https://github.com/therecipe/haxe ) and [Swift ](https://github.com/therecipe/swift )
2017-06-09 00:50:14 +03:00
initial commit of the interop engine + new flutter module + fixes for minor issues
this commit introduces the new experimental `interop` module, which is used to allow the use of `therecipe/qt` from languages other than go or javascript.
as a start, there was support for the dart language added (currently only in combination with a custom flutter embedder engine, but plain dart support should follow soon).
the interop module makes great use of the qml/js interop functions and logic that were written to make `https://github.com/therecipe/entry` possible.
additional languages that are planned to be supported in the near future are: swift, kotlin and haxe (maybe with support for the c#, python and java targets, but if this isn't possible in some clean way then these languages will receive standalone bindings as well).
people using `therecipe/qt` from these new languages should then be able to use flutter (and dart) in combination with qt (and go/js) through this binding and also be able to easily communicate across the language barriers with the help of the interop functions.
the interop engine theoretically also makes a cgo-less `therecipe/qt` usage possible, which could be used to workaround the ever growing annoyances that are experienced when using cgo projects in combination with go modules.
the code for the custom flutter embedder that was created to make the flutter/dart binding work can be found in the `flutter` module. it currently only supports debug builds for the desktop targets, but if there is enough interest, then it shouldn't be too difficult to make release builds there, and on the mobile targets work as well (or even on "embedded" systems such as an raspberry pi for that matter).
an example repo how to use the new flutter/dart binding, will be published in the next few days.
2020-06-01 22:27:56 +03:00
Beside the language bindings provided, `therecipe/qt` also greatly simplifies the deployment of Qt applications to various software and hardware platforms.
2017-04-07 00:22:01 +03:00
2020-08-17 19:37:48 +03:00
At the time of writing, almost all Qt functions and classes are accessible, and you should be able to find everything you need to build fully featured Qt applications.
2020-01-25 23:18:38 +03:00
initial commit of the interop engine + new flutter module + fixes for minor issues
this commit introduces the new experimental `interop` module, which is used to allow the use of `therecipe/qt` from languages other than go or javascript.
as a start, there was support for the dart language added (currently only in combination with a custom flutter embedder engine, but plain dart support should follow soon).
the interop module makes great use of the qml/js interop functions and logic that were written to make `https://github.com/therecipe/entry` possible.
additional languages that are planned to be supported in the near future are: swift, kotlin and haxe (maybe with support for the c#, python and java targets, but if this isn't possible in some clean way then these languages will receive standalone bindings as well).
people using `therecipe/qt` from these new languages should then be able to use flutter (and dart) in combination with qt (and go/js) through this binding and also be able to easily communicate across the language barriers with the help of the interop functions.
the interop engine theoretically also makes a cgo-less `therecipe/qt` usage possible, which could be used to workaround the ever growing annoyances that are experienced when using cgo projects in combination with go modules.
the code for the custom flutter embedder that was created to make the flutter/dart binding work can be found in the `flutter` module. it currently only supports debug builds for the desktop targets, but if there is enough interest, then it shouldn't be too difficult to make release builds there, and on the mobile targets work as well (or even on "embedded" systems such as an raspberry pi for that matter).
an example repo how to use the new flutter/dart binding, will be published in the next few days.
2020-06-01 22:27:56 +03:00
Impressions
-----------
2018-12-18 22:22:12 +03:00
initial commit of the interop engine + new flutter module + fixes for minor issues
this commit introduces the new experimental `interop` module, which is used to allow the use of `therecipe/qt` from languages other than go or javascript.
as a start, there was support for the dart language added (currently only in combination with a custom flutter embedder engine, but plain dart support should follow soon).
the interop module makes great use of the qml/js interop functions and logic that were written to make `https://github.com/therecipe/entry` possible.
additional languages that are planned to be supported in the near future are: swift, kotlin and haxe (maybe with support for the c#, python and java targets, but if this isn't possible in some clean way then these languages will receive standalone bindings as well).
people using `therecipe/qt` from these new languages should then be able to use flutter (and dart) in combination with qt (and go/js) through this binding and also be able to easily communicate across the language barriers with the help of the interop functions.
the interop engine theoretically also makes a cgo-less `therecipe/qt` usage possible, which could be used to workaround the ever growing annoyances that are experienced when using cgo projects in combination with go modules.
the code for the custom flutter embedder that was created to make the flutter/dart binding work can be found in the `flutter` module. it currently only supports debug builds for the desktop targets, but if there is enough interest, then it shouldn't be too difficult to make release builds there, and on the mobile targets work as well (or even on "embedded" systems such as an raspberry pi for that matter).
an example repo how to use the new flutter/dart binding, will be published in the next few days.
2020-06-01 22:27:56 +03:00
[Gallery ](https://github.com/therecipe/qt/wiki/Gallery ) of example applications.
2017-04-07 00:22:01 +03:00
initial commit of the interop engine + new flutter module + fixes for minor issues
this commit introduces the new experimental `interop` module, which is used to allow the use of `therecipe/qt` from languages other than go or javascript.
as a start, there was support for the dart language added (currently only in combination with a custom flutter embedder engine, but plain dart support should follow soon).
the interop module makes great use of the qml/js interop functions and logic that were written to make `https://github.com/therecipe/entry` possible.
additional languages that are planned to be supported in the near future are: swift, kotlin and haxe (maybe with support for the c#, python and java targets, but if this isn't possible in some clean way then these languages will receive standalone bindings as well).
people using `therecipe/qt` from these new languages should then be able to use flutter (and dart) in combination with qt (and go/js) through this binding and also be able to easily communicate across the language barriers with the help of the interop functions.
the interop engine theoretically also makes a cgo-less `therecipe/qt` usage possible, which could be used to workaround the ever growing annoyances that are experienced when using cgo projects in combination with go modules.
the code for the custom flutter embedder that was created to make the flutter/dart binding work can be found in the `flutter` module. it currently only supports debug builds for the desktop targets, but if there is enough interest, then it shouldn't be too difficult to make release builds there, and on the mobile targets work as well (or even on "embedded" systems such as an raspberry pi for that matter).
an example repo how to use the new flutter/dart binding, will be published in the next few days.
2020-06-01 22:27:56 +03:00
[JavaScript Demo ](https://therecipe.github.io/entry ) | *[source](https://github.com/therecipe/entry)*
2018-03-20 16:52:35 +03:00
2019-01-13 05:36:26 +03:00
Installation
------------
2020-06-02 16:54:36 +03:00
The following instructions assume that you already installed [Go ](https://golang.org/dl/ ) and [Git ](https://git-scm.com/downloads )
initial commit of the interop engine + new flutter module + fixes for minor issues
this commit introduces the new experimental `interop` module, which is used to allow the use of `therecipe/qt` from languages other than go or javascript.
as a start, there was support for the dart language added (currently only in combination with a custom flutter embedder engine, but plain dart support should follow soon).
the interop module makes great use of the qml/js interop functions and logic that were written to make `https://github.com/therecipe/entry` possible.
additional languages that are planned to be supported in the near future are: swift, kotlin and haxe (maybe with support for the c#, python and java targets, but if this isn't possible in some clean way then these languages will receive standalone bindings as well).
people using `therecipe/qt` from these new languages should then be able to use flutter (and dart) in combination with qt (and go/js) through this binding and also be able to easily communicate across the language barriers with the help of the interop functions.
the interop engine theoretically also makes a cgo-less `therecipe/qt` usage possible, which could be used to workaround the ever growing annoyances that are experienced when using cgo projects in combination with go modules.
the code for the custom flutter embedder that was created to make the flutter/dart binding work can be found in the `flutter` module. it currently only supports debug builds for the desktop targets, but if there is enough interest, then it shouldn't be too difficult to make release builds there, and on the mobile targets work as well (or even on "embedded" systems such as an raspberry pi for that matter).
an example repo how to use the new flutter/dart binding, will be published in the next few days.
2020-06-01 22:27:56 +03:00
2020-08-17 19:37:48 +03:00
#### (Experimental) cgo-less version (try this first, if you are new and want to test this binding)
##### Windows
```powershell
go get -ldflags="-w" github.com/therecipe/examples/basic/widgets && for /f %v in ('go env GOPATH') do %v\bin\widgets.exe
```
##### macOS/Linux
```bash
go get -ldflags="-w" github.com/therecipe/examples/basic/widgets & & $(go env GOPATH)/bin/widgets
```
#### Default version
2019-01-13 05:39:57 +03:00
##### Windows [(more info)](https://github.com/therecipe/qt/wiki/Installation-on-Windows)
2019-01-13 05:36:26 +03:00
```powershell
2019-10-23 02:27:33 +03:00
set GO111MODULE=off
go get -v github.com/therecipe/qt/cmd/... && for /f %v in ('go env GOPATH') do %v\bin\qtsetup test && %v\bin\qtsetup -test=false
2019-01-13 05:36:26 +03:00
```
2019-01-13 05:39:57 +03:00
##### macOS [(more info)](https://github.com/therecipe/qt/wiki/Installation-on-macOS)
2019-01-13 05:36:26 +03:00
```bash
2019-10-23 02:27:33 +03:00
export GO111MODULE=off; xcode-select --install; go get -v github.com/therecipe/qt/cmd/... & & $(go env GOPATH)/bin/qtsetup test & & $(go env GOPATH)/bin/qtsetup -test=false
2019-01-13 05:36:26 +03:00
```
2019-01-13 05:39:57 +03:00
##### Linux [(more info)](https://github.com/therecipe/qt/wiki/Installation-on-Linux)
2019-01-13 05:36:26 +03:00
```bash
2019-10-23 02:27:33 +03:00
export GO111MODULE=off; go get -v github.com/therecipe/qt/cmd/... & & $(go env GOPATH)/bin/qtsetup test & & $(go env GOPATH)/bin/qtsetup -test=false
2019-01-13 05:36:26 +03:00
```
2018-03-20 16:52:35 +03:00
Resources
---------
initial commit of the interop engine + new flutter module + fixes for minor issues
this commit introduces the new experimental `interop` module, which is used to allow the use of `therecipe/qt` from languages other than go or javascript.
as a start, there was support for the dart language added (currently only in combination with a custom flutter embedder engine, but plain dart support should follow soon).
the interop module makes great use of the qml/js interop functions and logic that were written to make `https://github.com/therecipe/entry` possible.
additional languages that are planned to be supported in the near future are: swift, kotlin and haxe (maybe with support for the c#, python and java targets, but if this isn't possible in some clean way then these languages will receive standalone bindings as well).
people using `therecipe/qt` from these new languages should then be able to use flutter (and dart) in combination with qt (and go/js) through this binding and also be able to easily communicate across the language barriers with the help of the interop functions.
the interop engine theoretically also makes a cgo-less `therecipe/qt` usage possible, which could be used to workaround the ever growing annoyances that are experienced when using cgo projects in combination with go modules.
the code for the custom flutter embedder that was created to make the flutter/dart binding work can be found in the `flutter` module. it currently only supports debug builds for the desktop targets, but if there is enough interest, then it shouldn't be too difficult to make release builds there, and on the mobile targets work as well (or even on "embedded" systems such as an raspberry pi for that matter).
an example repo how to use the new flutter/dart binding, will be published in the next few days.
2020-06-01 22:27:56 +03:00
- [Installation ](https://github.com/therecipe/qt/wiki/Installation )
2018-03-20 16:52:35 +03:00
- [Getting Started ](https://github.com/therecipe/qt/wiki/Getting-Started )
2018-12-18 22:22:12 +03:00
- [Wiki ](https://github.com/therecipe/qt/wiki )
2018-03-20 16:52:35 +03:00
- [Qt Documentation ](https://doc.qt.io/qt-5/classes.html )
2018-12-18 22:22:12 +03:00
- [FAQ ](https://github.com/therecipe/qt/wiki/FAQ )
2018-03-20 16:52:35 +03:00
- [#qt-binding ](https://gophers.slack.com/messages/qt-binding/details ) Slack channel ([invite](https://invite.slack.golangbridge.org)\)
Deployment Targets
------------------
2017-04-07 00:22:01 +03:00
2019-10-06 23:14:18 +03:00
| Target | Arch | Linkage | Docker Deployment | Host OS |
|:------------------------:|:----------------:|:-------------------------:|:-----------------:|:-------:|
| Windows | 32 / 64 | dynamic / static | Yes | Any |
| macOS | 64 | dynamic | Yes | Any |
| Linux | arm / arm64 / 64 | dynamic / static / system | Yes | Any |
| Android (+Wear) | arm / arm64 | dynamic | Yes | Any |
| Android-Emulator (+Wear) | 32 | dynamic | Yes | Any |
| SailfishOS | arm | system | Yes | Any |
| SailfishOS-Emulator | 32 | system | Yes | Any |
| Raspberry Pi (1/2/3) | arm | dynamic / system | Yes | Any |
| Ubuntu Touch | arm / 64 | system | Yes | Any |
| JavaScript | 32 | static | Yes | Any |
| WebAssembly | 32 | static | Yes | Any |
| iOS | arm64 | static | No | macOS |
| iOS-Simulator | 64 | static | No | macOS |
| AsteroidOS | arm | system | No | Linux |
| FreeBSD | 32 / 64 | system | No | FreeBSD |
2017-04-07 00:22:01 +03:00
License
2018-03-20 16:52:35 +03:00
-------
2018-11-06 20:16:33 +03:00
This package is released under [LGPLv3 ](https://opensource.org/licenses/LGPL-3.0 )
2016-12-30 01:31:55 +03:00
initial commit of the interop engine + new flutter module + fixes for minor issues
this commit introduces the new experimental `interop` module, which is used to allow the use of `therecipe/qt` from languages other than go or javascript.
as a start, there was support for the dart language added (currently only in combination with a custom flutter embedder engine, but plain dart support should follow soon).
the interop module makes great use of the qml/js interop functions and logic that were written to make `https://github.com/therecipe/entry` possible.
additional languages that are planned to be supported in the near future are: swift, kotlin and haxe (maybe with support for the c#, python and java targets, but if this isn't possible in some clean way then these languages will receive standalone bindings as well).
people using `therecipe/qt` from these new languages should then be able to use flutter (and dart) in combination with qt (and go/js) through this binding and also be able to easily communicate across the language barriers with the help of the interop functions.
the interop engine theoretically also makes a cgo-less `therecipe/qt` usage possible, which could be used to workaround the ever growing annoyances that are experienced when using cgo projects in combination with go modules.
the code for the custom flutter embedder that was created to make the flutter/dart binding work can be found in the `flutter` module. it currently only supports debug builds for the desktop targets, but if there is enough interest, then it shouldn't be too difficult to make release builds there, and on the mobile targets work as well (or even on "embedded" systems such as an raspberry pi for that matter).
an example repo how to use the new flutter/dart binding, will be published in the next few days.
2020-06-01 22:27:56 +03:00
Qt itself is licensed and available under multiple [licenses ](https://www.qt.io/licensing ).
