Skia VS GLFW

If you're interested in node-compatible canvas implementations, there are several:

* canvaskit-wasm, from the skia project. I don't think it's gpu-accelerated: https://github.com/google/skia/tree/main/modules/canvaskit/n...

* @napi-rs/canvas. This is the fastest binding: https://github.com/Brooooooklyn/canvas?tab=readme-ov-file#pe...

* node-canvas. Uses Cairo instead of Skia: https://github.com/Automattic/node-canvas

Yes [4].

> [1] The library is used as of 2023 in Google Chrome, ChromeOS, ChromiumOS, Mozilla Firefox, Mozilla Thunderbird, Android, Firefox OS, Flutter,[5] Avalonia (from Alpha 4), LibreOffice (from version 7.0) and RAD Studio[6](since version 12.0).

> [2] Changes to the Skia repository will be rolled into Chromium by the AutoRoll bot several times per day.

> [3] It serves as the graphics engine for Google Chrome and ChromeOS, Android, Flutter, and many other products.

[1]: https://en.wikipedia.org/wiki/Skia_Graphics_Engine

[2]: https://skia.org/docs/dev/chrome/

[3]: https://skia.org/

[4]: https://github.com/chromium/chromium/tree/main/skia

Actually, that's not entirely accurate. The lottie-web library itself doesn't support rendering to WebGL. However, there is a package called canvaskit-wasm that wraps Skia (a graphics engine) with WebAssembly (wasm). This package includes a module called skottie which supports rendering animations into a WebGL surface. However, there is a drawback with this approach: using wasm requires loading a relatively large package, and it's uncertain whether all features are supported correctly, as the official compatibility table that tracks lottie support on different platforms does not include skottie.

Skia is pretty great if you can get it running.

The imgs are mainly used by Tencent QQ and Baidu Tieba users. QQ and Tieba compress imgs by default, so the popular imgs (in China we call them "屌图" or "表情包") would be compressed million of times during the spreading, causing the super low quality. These APPs on Android are using Skia for image processing, which suffering from a legendary bug: result would be more green. The bug was fixed in 2016: https://github.com/google/skia/commit/c7d01d3e1d3621907c27b283fb7f8b6e177c629d

As I discussed in my previous devlog, I decided to go with glfw for handling the window creation for this engine. It is a library I used a ton before. And while I do fancy replacing it later, it will suffice for now.

Out of all of these, the first category--the operating system dependencies--is probably the one I thought about the most. Since SDL was out of the picture, I saw GLFW as a potential choice for handling window creation and input. An obvious choice, by many. And, seeing how I already had used it before, I thought it was obvious to me as well. Yet, there was a feeling I did not need it. After all, I decided from the start that I would only support Windows and Linux. Not for any particular reason other than I use Linux on a daily basis and Windows has the bigger market. I did not have a Mac machine lying around somewhere (poor. I'm poor, basically). And as for consoles, well, that was a long stretch. I did not see the possibility of me ever needing to port my games to consoles. At least not for the time being. And so, that means I only had to deal with the Win32, X11, and Wayland APIs. I say it as though it is an easy affair. It is not. Far from it. Especially if you had never dealt with these APIs before and had to start learning them, which was my case. So, instead, I picked a middle ground. I would use GLFW but I would design my API in such a way that would be easier to switch away from it in the future if needed. I'll write a more in-depth article about the window system and whatnot in the future.

Why would any software developer use an API? Well, it's not to get rid of that shirt stain you had for the last three days that's for sure. Instead, we crazy bunch use APIs to progress our software development at a faster rate. I don't really want to work with the Windows API nor do I care to open the rotten can of sardines that is the X11 API. But, thankfully, I don't have to. There are plenty of APIs that handle that for me. And they handle it very nicely too. GLFW is one of these APIs. Easy to use, fast to set up, and overall doesn't have any overhead. Handles window creation, input, and any operating system-specific stuff. It solves a clear and appropriate problem. Left pad, however, is the complete opposite. Does it solve a problem? Sure it does... if you were hit on the head with a baseball bat 17 times. Can't I at least add padding to any direction? No? Does it just have to be the left? Even though we C++ folks can say that the JavaScript weirdos are the only ones who would do such a heinous thing, that wouldn't be the entire story. It would be hypocritical even to assume that all of the useless APIs exist only in the JS ecosystem. Although being hypocritical is my strong point, even I would stop you right there. If there is an ecosystem that would be perfect for breeding unnecessarily complex, widely inefficient, and completely useless libraries, it would be C++... Rust would come at a close second but C++ is the mother of all useless and complex libraries.

Minecraft runs on various Javas.

And there's a known issue with an interaction between minecraft, Java, and the video drivers that crashes out and it can be traced back all the way to here: https://github.com/glfw/glfw/issues/1997

It's not fixed.

Window context manager - glfw, sdl

Types of tools for creating a gui (and how those tools approximately work): 1. Utilize the native _graphical interface API_, and depending on the platform, they have specific layers to interface: * Wayland, X11, for Linux * [GDI](https://learn.microsoft.com/en-us/windows/win32/gdi/windows-gdi) for windows * [Quartz](https://en.wikipedia.org/wiki/Quartz\_(graphics\_layer)) for macOS Example - GTK uses [wayland](https://gitlab.gnome.org/GNOME/gtk/-/blob/main/docs/reference/gdk/wayland.md) ([source code](https://gitlab.gnome.org/GNOME/gtk/-/tree/main/gdk/win32)) [X11](https://gitlab.gnome.org/GNOME/gtk/-/blob/main/docs/reference/gdk/x11.md) ([source code](https://gitlab.gnome.org/GNOME/gtk/-/tree/main/gdk/x11)) GDI ([source code](https://gitlab.gnome.org/GNOME/gtk/-/tree/main/gdk/win32)) Quartz ([source code](https://gitlab.gnome.org/GNOME/gtk/-/tree/main/gdk/macos)) [How to use wayland display server](https://bugaevc.gitbooks.io/writing-wayland-clients/content/black-square/the-wayland-client-library.html) (TODO missing "animation" section) 2. Utilize opengl _or other low level graphics api's_ with window context, use GPU to render widgets * Window context manager - [glfw](https://github.com/glfw/glfw), [sdl](https://www.libsdl.org/) * contexts and surfaces, reading input, handling events Example: ImGui, NanoVG, Nuklear, raylib Why? Mainly used for game development, but also good for gui's. _(i haven't seen any examples that uses this method that are used for developing general-use graphical user interfaces.)_

GLFW: A library for window creation and managing user input.

Not SDL2, but GLFW has something like that under the tests/ directory:

https://github.com/glfw/glfw/blob/master/tests/triangle-vulk...

I'm not familiar with LWJGL, my 5 seconds on their website makes me think you might be looking for something like GLFW https://www.glfw.org/ to handle I/O and window creation/management.