SixtyFPS is a toolkit to efficiently develop fluid graphical user interfaces for any display: embedded devices and desktop applications

Overview

SixtyFPS

Build Status Discussions

SixtyFPS is a toolkit to efficiently develop fluid graphical user interfaces for any display: embedded devices and desktop applications. We support multiple programming languages, such as Rust, C++, and JavaScript.

Our design goals are:

  • Lightweight: Fit into a few hundred kilobytes of RAM and require little processing power.
  • Straightforward: Programmers and designers should feel productive and be able to enjoy the design and development process. The APIs should be consistent, easy to use, and intuitive, no matter the target language. High-quality documentation should describe the APIs, teach concepts and how to use them.
  • Native: We support many different target platforms, from embedded devices to desktops including mobile and web. Both the user and the developer should feel at home on each platform. The look and feel and experience should match the users' expectations of a native application.

Current Status

SixtyFPS is in active development. Its state of development depends on the kind of application.

  • Embedded: Ready! SixtyFPS is already happily used by customers on embedded devices (running on an Arm processor with Linux). We are also looking into supporting microcontrollers.
  • Desktop: In Progress. SixtyFPS is usable on Windows, Linux and Mac. We plan on building up the desktop support in subsequent releases to reach the level of integration we're aiming for.
  • Mobile (Android/iOS): Todo. We haven't started supporting mobile platforms yet, but it is our intention to do so in the future.
  • Web: Our focus is on Embedded and Desktop applications. We do not intend to compete in the web space as a primary platform. That said, SixtyFPS can compile to WebAssembly and the demos are running in a web browser. But the web support is currently limited to demo purposes.

Documentation

Refer to the README of each language directory in the api sub-folder:

The examples folder contains examples and demos. The docs folder contains build instructions and internal developer docs.

Demos running in WebAssembly Simulation

Click on the screenshots to run the WebAssembly simulation

Printer Demo Slide Puzzle Todo Widget Gallery
Screenshot of the Printer Demo Screenshot of the Slide Puzzle Screenshot of the Todo Demo Screenshot of the Gallery Demo

Desktop Native Widgets

Windows macOS Linux
Screenshot of the Gallery on Windows Screenshot of the Gallery on macOS Screenshot of the Gallery on Linux

The .60 Markup Language

SixtyFPS comes with a markup language that is specifically designed for user interfaces. This language provides a powerful way to describe graphical elements, their placement, and the flow of data through the different states. It is a familiar syntax to describe the hierarchy of elements and property bindings. Here's the obligatory "Hello World":

HelloWorld := Window {
    width: 400px;
    height: 400px;

    Text {
       y: parent.width / 2;
       x: parent.x + 200px;
       text: "Hello, world";
       color: blue;
    }
}

Check out the language reference for more details.

Architecture

An application is composed of the business logic written in Rust, C++, or JavaScript and the .60 user interface design markup, which is compiled to native code.

Architecture Overview

Compiler

The .60 files are compiled ahead of time. The expressions in the .60 are pure functions that the compiler can optimize. For example, the compiler could choose to "inline" properties and remove those that are constant or unchanged. In the future we hope to improve rendering time on low end devices by pre-processing images and text. The compiler could determine that a Text or an Image element is always on top of another Image in the same location. Consequently both elements could be rendered ahead of time into a single element, thus cutting down on rendering time.

The compiler uses the typical compiler phases of lexing, parsing, optimization, and finally code generation. It provides different back-ends for code generation in the target language. The C++ code generator produces a C++ header file, the Rust generator produces Rust code, and so on. An interpreter for dynamic languages is also included.

Runtime

The runtime library consists of an engine that supports properties declared in the .60 language. Components with their elements, items, and properties are laid out in a single memory region, to reduce memory allocations.

Rendering backends and styles are configurable at compile time. Current there are two back-ends:

  • The gl backend uses OpenGL ES 2.0 for rendering.
  • The qt backend uses Qt's QStyle to achieve native looking widgets. In the future it could also use QPainter.

Tooling

We have a few tools to help with the development of .60 files:

  • A LSP Server that adds things like auto-complete and live preview of the .60 files to many editors
  • It is bundled in a Visual Studio Code Extension accessible from the market place
  • A sixtyfps-viewer tool which display the .60 files. With the --auto-reload argument, makes it easy to preview your UI as you are working it (when using the LSP preview is not possible)
  • An online editor to try out .60 syntax without installing anything (sources)
  • An updater to convert the .60 files from previous version to the newer version
  • An experimental Figma importer

Contributions

We welcome your contributions: in the form of code, bug reports or feedback.

  • If you see an RFC tag on an issue, feel free to chime in.
  • For contribution guidelines see CONTRIBUTING.md. The dual-licensing requires the contributor to accept a CLA.

License

This software is provided under a dual licensing scheme:

See also the Licensing FAQ

Frequently Asked Questions

Please see our separate FAQ.

About us

Olivier and Simon started their open source journey in the KDE project, the popular Open Source Desktop Environment for Linux. Later they met while working together in a small company in Norway called Trolltech, on the Qt C++ toolkit. Here, they gained valuable experience in API design, cross-platform software development and user interface components. Simon continued in the Qt Company as one lead developer and maintainer of the QtQml engine, while Olivier co-founded Woboq, a software consulting company. Years later, and now based in Berlin, they are starting a new project. With SixtyFPS they aim to make developing user interfaces fun for everyone: from JavaScript, C++, or Rust developers all the way to UI/UX designers.

Contact us

Feel free to join Github discussions for general chat or questions. Use Github issues to report public suggestions or bugs.

To contact us privately send an email to [email protected]

For chat, we also have our Mattermost instance

Comments
  • Add support for dispatching key events through the public platform API

    Add support for dispatching key events through the public platform API

    Now it is possible to dispatch key events from the public api using the WindowEvent enum. Related to #1745. Add impl From<char> for SharedString

    opened by FloVanGH 21
  • Unable to build on Ubuntu 20.04.2

    Unable to build on Ubuntu 20.04.2

    Unable to build on ubuntu based on instructions given.Am I missing something?. Attached terminal steps performed:

    [email protected]:~/packages/sixtyfps/cppbuild$ cmake --GNinja .. -- The CXX compiler identification is GNU 9.3.0 -- Check for working CXX compiler: /usr/bin/c++ -- Check for working CXX compiler: /usr/bin/c++ -- works -- Detecting CXX compiler ABI info -- Detecting CXX compiler ABI info - done -- Detecting CXX compile features -- Detecting CXX compile features - done info: This is the version for the rustup toolchain manager, not the rustc compiler. info: The currently active rustc version is rustc 1.52.1 (9bc8c42bb 2021-05-09) -- Rust Toolchain: stable-x86_64-unknown-linux-gnu -- Rust Target: x86_64-unknown-linux-gnu -- Found Rust: /home/shekhar/.rustup/toolchains/stable-x86_64-unknown-linux-gnu/bin/rustc (found version "1.52.1") -- Defaulting Cargo to build debug -- Using Corrosion as a subdirectory -- Looking for C++ include pthread.h -- Looking for C++ include pthread.h - found -- Performing Test CMAKE_HAVE_LIBC_PTHREAD -- Performing Test CMAKE_HAVE_LIBC_PTHREAD - Failed -- Looking for pthread_create in pthreads -- Looking for pthread_create in pthreads - not found -- Looking for pthread_create in pthread -- Looking for pthread_create in pthread - found -- Found Threads: TRUE
    CMake Error: File /CMakeLists.cmake.in does not exist. CMake Error at /usr/share/cmake-3.16/Modules/FetchContent.cmake:891 (configure_file): configure_file Problem configuring file Call Stack (most recent call first): /usr/share/cmake-3.16/Modules/FetchContent.cmake:1006 (__FetchContent_directPopulate) /usr/share/cmake-3.16/Modules/FetchContent.cmake:1047 (FetchContent_Populate) examples/iot-dashboard/CMakeLists.txt:21 (FetchContent_MakeAvailable)

    -- Configuring incomplete, errors occurred! See also "/home/shekhar/packages/sixtyfps/cppbuild/CMakeFiles/CMakeOutput.log". See also "/home/shekhar/packages/sixtyfps/cppbuild/CMakeFiles/CMakeError.log". [email protected]:~/packages/sixtyfps/cppbuild$ cmake --GNinja .. -- Rust Toolchain: stable-x86_64-unknown-linux-gnu -- Rust Target: x86_64-unknown-linux-gnu -- Defaulting Cargo to build debug -- Using Corrosion as a subdirectory CMake Error: File /CMakeLists.cmake.in does not exist. CMake Error at /usr/share/cmake-3.16/Modules/FetchContent.cmake:891 (configure_file): configure_file Problem configuring file Call Stack (most recent call first): /usr/share/cmake-3.16/Modules/FetchContent.cmake:1006 (__FetchContent_directPopulate) /usr/share/cmake-3.16/Modules/FetchContent.cmake:1047 (FetchContent_Populate) examples/iot-dashboard/CMakeLists.txt:21 (FetchContent_MakeAvailable)

    -- Configuring incomplete, errors occurred! See also "/home/shekhar/packages/sixtyfps/cppbuild/CMakeFiles/CMakeOutput.log". See also "/home/shekhar/packages/sixtyfps/cppbuild/CMakeFiles/CMakeError.log". [email protected]:~/packages/sixtyfps/cppbuild$

    bug language-c++ 
    opened by ZEPORATH 21
  • Stack overflow on Windows in Rust Debug Builds

    Stack overflow on Windows in Rust Debug Builds

    Due to the inlining the generated structures tend to become rather big (the gallery for example ~13kb with the ugly style), which on debug builds with Rust on Windows tends to result in a bunch of copies of said struct. That can lead to the process running out of stack space.

    bug platform-win language-rust 
    opened by tronical 19
  • Set the rpath to Qt for Rust binaries

    Set the rpath to Qt for Rust binaries

    For C++ apps we apply rpath to the cdylib implicitly via qttypes, but link flags for rust binaries are not transitively propagated but require explicit opt-in by the top-level crate. However we want that convenience, to avoid Rust apps having to deal with Qt backend specific code in their build.rs. Therefore we use the _DEP mechanism to get the qt library path from the qttypes crate and write it into a generic file in the qt backend's build.rs, which is then picked up by sixtyfps-build.

    We'll use the same mechanism to propagate link flags for the MCU build (such as the linker script).

    cc #566

    opened by tronical 16
  • Widget focus

    Widget focus

    Do not derive widgets from FocusScope

    We expose less functionality this way:-)

    Add enabled property to FocusScope

    Allow for a bool to enable/disable focus delivery.

    Make the Button accept focus

    ... and handle space/return keys to click() it!

    opened by hunger 14
  • error: failed to run custom build command for `servo-fontconfig-sys v5.1.0`

    error: failed to run custom build command for `servo-fontconfig-sys v5.1.0`

    error: failed to run custom build command for servo-fontconfig-sys v5.1.0

    Caused by: process didn't exit successfully: /home/mahdi/Rust/my-project/target/debug/build/servo-fontconfig-sys-136e4a39fa7e8154/build-script-build (exit status: 101) --- stdout cargo:rerun-if-env-changed=FONTCONFIG_NO_PKG_CONFIG cargo:rerun-if-env-changed=PKG_CONFIG_x86_64-unknown-linux-gnu cargo:rerun-if-env-changed=PKG_CONFIG_x86_64_unknown_linux_gnu cargo:rerun-if-env-changed=HOST_PKG_CONFIG cargo:rerun-if-env-changed=PKG_CONFIG cargo:rerun-if-env-changed=FONTCONFIG_STATIC cargo:rerun-if-env-changed=FONTCONFIG_DYNAMIC cargo:rerun-if-env-changed=PKG_CONFIG_ALL_STATIC cargo:rerun-if-env-changed=PKG_CONFIG_ALL_DYNAMIC cargo:rerun-if-env-changed=PKG_CONFIG_PATH_x86_64-unknown-linux-gnu cargo:rerun-if-env-changed=PKG_CONFIG_PATH_x86_64_unknown_linux_gnu cargo:rerun-if-env-changed=HOST_PKG_CONFIG_PATH cargo:rerun-if-env-changed=PKG_CONFIG_PATH cargo:rerun-if-env-changed=PKG_CONFIG_LIBDIR_x86_64-unknown-linux-gnu cargo:rerun-if-env-changed=PKG_CONFIG_LIBDIR_x86_64_unknown_linux_gnu cargo:rerun-if-env-changed=HOST_PKG_CONFIG_LIBDIR cargo:rerun-if-env-changed=PKG_CONFIG_LIBDIR cargo:rerun-if-env-changed=PKG_CONFIG_SYSROOT_DIR_x86_64-unknown-linux-gnu cargo:rerun-if-env-changed=PKG_CONFIG_SYSROOT_DIR_x86_64_unknown_linux_gnu cargo:rerun-if-env-changed=HOST_PKG_CONFIG_SYSROOT_DIR cargo:rerun-if-env-changed=PKG_CONFIG_SYSROOT_DIR

    --- stderr thread 'main' panicked at '"pkg-config" "--libs" "--cflags" "fontconfig" "fontconfig >= 2.11.1" did not exit successfully: exit status: 1 --- stderr Package fontconfig was not found in the pkg-config search path. Perhaps you should add the directory containing fontconfig.pc' to the PKG_CONFIG_PATH environment variable No package 'fontconfig' found Package fontconfig was not found in the pkg-config search path. Perhaps you should add the directory containingfontconfig.pc' to the PKG_CONFIG_PATH environment variable No package 'fontconfig' found ', /home/mahdi/.cargo/registry/src/github.com-1ecc6299db9ec823/servo-fontconfig-sys-5.1.0/build.rs:34:17 note: run with RUST_BACKTRACE=1 environment variable to display a backtrace warning: build failed, waiting for other jobs to finish... error: build failed

    opened by Behkar 14
  • Fix mouse exit events not triggered by scrolling a Flickable

    Fix mouse exit events not triggered by scrolling a Flickable

    This is more of an POC of a fix to #1107. Basically the main idea here is to make sure that mouse events are handled as usual by child items in case of a mouse scroll event on a flickable, so they are part of the previous mouse grabber stack which is required to be included in the exit event dispatching. This works for the case shown on the video at the bottom (mouse leave) but I think it's not the most complete solution here. Probably a better solution would be to convert the scroll event to a move event as this would be more correct for the child items. I also had to move the call to send_exit_events after the actual event handling to be able to catch the updated scroll position in the frame it was changed and not 1 frame later. While this wasn't a huge issue when scrolling slowly, scrolling fast could easily trigger a wrong hovering state as the jump in a single frame was greater than a single item in height.

    Open questions:

    • Is introducing a new input event filter result the best option here?
    • Using EventIgnore as result of the flickable event handler feels a bit hacky.
    • Could there be any regressions or unintended side effects caused by sending exit events at the end of event handling?
    • While the mouse event should be forwarded to child items only, it is also forwarded to siblings if I'm not mistaken, which is not desired

    https://user-images.githubusercontent.com/9491603/168012405-f40b14e6-e074-4f7c-a4ba-afe12130872b.mp4

    Fixes #1107 Fixes #1278

    opened by levrik 13
  • use log::debug macro for debug function in .60 language

    use log::debug macro for debug function in .60 language

    It would be nice if using the built-in debug function in .60 files autogenerated Rust code which used the debug macro from the log crate. This would allow applications to choose the logging implementation instead of always printing directly to standard out. It would also be nice to add functions for the other log levels (trace, info, warn, error).

    good first issue 
    opened by Be-ing 13
  • Just for quick feedback for keyboard modifier handling

    Just for quick feedback for keyboard modifier handling

    This is not final at all the move_cursor_by_word() is more or less a copy with duplication of move_cursor etc. I just need some quick feedback about the SemanticModifier part. @tronical: you didn't like that when I wanted to add it to KeyboardModifiers.

    But I think some sort of abstraction like that is good. Actually there already exists the AnchorMode, which serves a similar purpose, but it needs a struct and a From implementation for every semantic/mode.

    If you are ok with my approach, I would also replace the AnchorMode with the SemanticModifier, by adding a KeepAnchor to it.

    Of course if you have an idea for a better abstraction, I wanna hear about it.

    opened by lukas-jung 12
  • Array index

    Array index

    This branch adds support for indexing into arrays/models. As it stands, out-of-bounds access will panic. Will change the behavior as directed. As before, I am unfortunately not able to test the cpp implementation.

    opened by jamesblacklock 12
  • Keyboard events

    Keyboard events

    As far as I understand, keyboard events are not currently exposed via public API. That is, I can not cobble together my own custom LineInput out of Rectangle and a Text.

    opened by matklad 12
  • Web JS API

    Web JS API

    We currently have the wasm interpreter that we use in the documentation and the online editor. We should add API so that we can also set/get properties and callback from JS on the browser

    opened by ogoffart 1
  • Clippy warnings

    Clippy warnings

    The code is full of clippy warning. It would be nice to clean up a bit. Especially the part in generated code, because our user shouldn't get clippy warnings in their code because they are using Slint.

    Ideally it should be tested in CI than there is no warnings in the generated code (by, eg, running clippy on the rust test)

    Note: some common sense should be applied when fixing some warnings. Not all suggestions from clippy makes sense, and sometime it's ok to just ignore them. Performance suggestions almost always make sense, or the ones about using function that we maybe did not think of while writing the code. But style ones are sometimes a bit dubious.

    good first issue 
    opened by ogoffart 1
  • Syntax for repeated elements and conditional elements

    Syntax for repeated elements and conditional elements

    Currently

    for tile[i] in memory-tiles: MemoryTile {
       // ...      
    }
    
    if foo.some-conditoin : SomeElement {
    }
    

    It was suggested in https://github.com/slint-ui/slint/discussions/1818#discussioncomment-4182871 to add brace to extand for more elements:

    for tile[i] in memory-tiles {
            MemoryTile {
                // ...
            }
            // potentially more elements
        }
    }
    
    if foo.some-condition {
        SomeElement {
        }
        SomeOtherElement {
        }
    }
    

    It is assumed that this new scope is not in iteself an element, and when used in layout or other components that do something with their direct children the sub-element are considered direct children.

    Unresolved questions:

    • Should the old syntax be deprecated or be kept as a shortened version when there is only one element? (after all, this would otherwise add a level of indentation for the common case)
    • Can property be declared in the for or if scope? If yes, how do we reference them if we want them to be qualified (we don't)
    rfc 
    opened by ogoffart 2
  • Interfaces for style

    Interfaces for style

    Currently, the style must re-implement a lot of components, but there is nothing that checks that these component have the same interface/properties.

    The idea would be to build interfaces like so: (based on the current interface of Button https://docs.rs/slint/latest/slint/docs/widgets/index.html#button)

    interface Button {
       in property <string> text;
       in property <bool> checkable;
       in-out property <string> checked;
       out property <bool> pressed;
       in property <image> icon;
       callback clicked();
    }
    

    Then, the style would have to implement this interface:

    // FIXME should we import that? from where, should it be bluit-in
    import { Button } from "std.slint"; 
    
    component MyStyleButton implements Button {
       pressed: ta.pressed; // can set output properties
       Text { text: root.text } // can access property
       ta := TouchArea { clicked => { root.clicked() } } // call callbacks
       
       in property <int> extra_prop; // ERROR!  not allowed to add public properties
    }
    
    // re-export the MyStyleButton as the Button of our style
    export MyStyleButton as Button;
    

    It is a bit akward to have to go through MyStyleButton as a separate name, maybe we could allow component Button implements Button {...} and have different namespace for components and for interface.

    Unresolved question:

    • How do we make sure that the style implements all the widgets?
    • How do we make sure that a style don't export more than the required widget?
    • Is it a breaking change, in Slint, to add more widgets? Should we add some sort of versioning?
    • Should the interface allow to also have some logic in them?
    • What about widgets like TabWidget or ListView that needs compiler support?
    • Should we even allow users to declare new interface, or are these just be builtin?
    rfc 
    opened by ogoffart 2
  • Online editor: question marks `???`  for some properties in the Properties tab

    Online editor: question marks `???` for some properties in the Properties tab

    Example, the model property of the gallery's side bar:

    image

    To reproduce:

    1. Open the gallery example in the online code editor
    2. put the text cursor on the SideBar
    3. There is a ??? in the model.

    Ths is somehow because the type was not recognize by the property view. But we should not show this question mark. If anything, i think the type should be shown as an icon on the left of the property, for all properties (hint: use emoji (eg: ⛓️🔢🔤📏☑️🗄️📊) if you don't have icons) But at least, the ??? should never be shown.

    online-editor 
    opened by ogoffart 0
Releases(v0.3.1)
Owner
SixtyFPS
SixtyFPS
SixtyFPS
An MQTT-based Virtual Wall for ESP8266 Devices and Gerber files to make the IR hat; this code and board can easily be adapted to be ANY infrared controller/remote!

Roomba-Virtual-Wall-ESP8266-MQTT An MQTT-based Virtual Wall for ESP8266 Devices I made this based off of the IRSend, IRremoteESP8266, and EspMQTTClien

null 8 Sep 20, 2021
Mongoose Embedded Web Server Library - a multi-protocol embedded networking library with TCP/UDP, HTTP, WebSocket, MQTT built-in protocols, async DNS resolver, and non-blocking API.

Mongoose - Embedded Web Server / Embedded Networking Library Mongoose is a networking library for C/C++. It implements event-driven non-blocking APIs

Cesanta Software 8.9k Nov 21, 2022
Login and send instagram direct message to any user ;)

DM-THIS-USER Very simple instagram tool,The idea is not in the tool, but in how to deal with the C language, especially with the openssl library and c

0xDADDY 6 May 14, 2022
Run statically-compiled WebAssembly apps on any embedded platform

embedded-wasm-apps Run native, statically-compiled AssemblyScript, Rust, C/C++, TinyGo, Zig, etc. apps on any platform How it works The approach is si

Volodymyr Shymanskyy 111 Nov 18, 2022
WebSockets in C for Embedded Applications

WebSockets in C WIC is a C99 implementation of rfc6455 websockets designed for embedded applications. WIC decouples the websocket protocol from the tr

Cameron Harper 56 Nov 17, 2022
About Add any Program in any language you like or add a hello world Program ❣️ if you like give us ⭐

Hello-World About Add any Program in any language you like or add a hello world Program ❣️ if you like give us ⭐ Give this Project a Star ⭐ If you lik

Lokesh Jangid 15 Oct 28, 2022
Cross-connect Linux interfaces with XDP

Cross-connect Linux interfaces with XDP redirect xdp-xconnect daemon is a long-running process that uses a YAML file as its configuration API. For exa

Michael Kashin 49 Oct 24, 2022
To have platform independent network interfaces over usb which is working with Linux, Windows, Mac OS ect.

To have platform independent network interfaces over usb which is working with Linux, Windows, Mac OS ect. called RNDIS. This project is a RNDIS demo, which addtionally implements a http server. It runs out of the box on a stm32f411 BlackPill board. My RNDIS library with an empty template for the second interface (which can ba UART, CAN, ETH or like in this demo a tcp/ip stack) can be found under following link: https://github.com/RDMsmartnetworks/STM32_HAL_RNDIS

Nico Korn 16 Sep 27, 2022
C++ framework for building lightweight HTTP interfaces

Pion Network Library C++ framework for building lightweight HTTP interfaces Project Home: https://github.com/rimmartin/pion-ng Documentation Retrievin

null 1 Dec 30, 2020
Graphical small-internet client for windows, linux, MacOS X and BSDs. Supports gemini, http, https, gopher, finger.

Graphical small-internet client for windows, linux, MacOS X and BSDs. Supports gemini, http, https, gopher, finger.

Felix Queißner 566 Nov 17, 2022
Encapsulates the two protocols of OpenVpn and Ikev2, you only need to enter the server IP and port number to realize the connection and status display, and the specific situation of the connection can be displayed at the same time。

NewVpnCore 封装了OpenVpn和Ikev2两种协议,只需要输入服务器IP和端口号即可实现连接和状态显示,同时可以显示连接的具体情况。 UniteVpn Core(第一版) 1. 模块说明 unitevpn:封装了vpn的操作和统一不同协议信息的模块 ikev2:IKEV2协议的源码 op

ZFashion 3 Jun 8, 2022
TCP/IP for Casio fx-9860 graphical calculators (with SLIP support, uIP stack)

fxIP TCP/IP stack and IRC client for Casio fx-9860/9750 calculators YouTube video of fxIP's IRC client, connecting to irc.libera.chat YouTube video of

Tobias Mädel 203 Nov 16, 2022
A graphical (Qt5) client for MPD

Cantata NOTE Cantata is now in a bug-fix only state. Therefore, new features are unlikly to be implemented unless pull requests are submitted. The cur

CraigD 1k Nov 22, 2022
Android and iOS SDK to display maps and geodata of swisstopo. Owner: simonroesch, Deputy: gjn

Open Swiss Maps SDK Android and iOS SDK to display maps and geodata of swisstopo Free map layers and geo data by swisstopo in your app Offer your mobi

geo.admin.ch 22 Aug 7, 2022
FreeRDP is a free remote desktop protocol library and clients

FreeRDP is a free implementation of the Remote Desktop Protocol (RDP), released under the Apache license. Enjoy the freedom of using your software wherever you want, the way you want it, in a world where interoperability can finally liberate your computing experience.

null 7.6k Nov 19, 2022
Show pressure & temperature readings from Home Assistant/MQTT on a mini display

home-assistant-barometer-display A mini Home Assistant display to show pressure & temperature readings (and made to look pretty with 'freeform pcb' br

David Barton 4 Jan 4, 2022
Jellyfin Desktop Client based on Plex Media Player

Jellyfin Media Player Based on (but not affiliated with) Plex Media Player. Please see: Corresponding web client: Repo Release API Docs in client-api.

Ian Walton 1.3k Nov 24, 2022
Share PC desktop to Raspberry Pi with WebRTC

Share PC desktop to Raspberry Pi with WebRTC

null 31 Nov 9, 2022
Dolphin is an emulator for running GameCube and Wii games on Windows, Linux, macOS, and recent Android devices.

Dolphin is a GameCube / Wii emulator, allowing you to play games for these two platforms on PC with improvements.

Dolphin Emulator 9.2k Nov 19, 2022