What is Reddit's opinion of
AppImageKit?
From 3.5 billion Reddit comments
➔ AppImageKit website
By popularity on Reddit, this Service is:
57 reviews of this app found across Reddit:
Different packaging system ≠ "different architecture"
You could run binary taken from one system on the other one if you have all required libraries for it. That's how AppImage (and Steam) works.
>Ideally I would just like to be able to hand the users a folder that contains foo.so and bar.out next to each other and they user just runs bar.out without having to do anything else.
Package your app as an AppImage. It's a reliable and field-tested method that isolates your app from the peculiarities of individual installs and distributions.
AppImage -- Linux apps that run anywhere.
You may look into AppImage if you have strict dependencies on some specific version (like for GTK3): https://appimage.org/.
This allows to have a binary that works universally on every Linux distributions. And it's way easier to integrate into a Linux distribution than a .deb.
> AppImage isn't comparable to the other two as it isn't truly cross-distro.
That's not quite correct. It doesn't have an independent multi-use core, but it is designed to be cross-distro by essentially linking/bundling in all dependencies into the binary.
> #Leading Linux distributions
> Download an application, make it executable, and run! No need to install. No system libraries or system preferences are altered. Can also run in a sandbox like Firejail
> Distribute your desktop Linux application in the AppImage format and win users running all common Linux distributions. Package once and run everywhere. Reach users on all major desktop distributions.
That is almost exactly what AppImage does. Only that we generally don't recommend to bundle everything, but instead re-use basic libraries that can be expected to be there on each target system (e.g., glibc), so as to not produce bloat. That is however just a recommendation to balance size vs. reliance on pre-installed libraries and can be done differently. In fact, some projects produce AppImages that bundle <u>everything</u>, down to glibc.
It's not just about Ubuntu. They are looking for a better way to distribute their software to 5+ Linux distributions.
From OPs link:
> As of this writing, we are currently building no fewer than five different versions of RStudio Desktop for Linux:
> * for RedHat/CentOS based systems; > * for Ubuntu based systems; > * for OpenSuSE based systems with an old libssl; > * for OpenSuSE based systems with a new libssl; and > * for Debian 9+ based systems.
> Despite this somewhat cumbersome matrix we still don't support many platforms and distributions.
> This is a general issue with Linux applications, at least on the desktop; because of differing installation systems, packaging requirements, and system libraries, packages conforming to each system's idiosyncrasies are necessary.
> Several attempts have been made to solve the problem by introducing an installation platform which encourages the bundling of dependencies (rather than relying on system versions), making application deployment on Linux more like it is on Mac/Windows. In true Linux fashion, there are many competing efforts:
> Flatpak - https://flatpak.org/
> Snapcraft - https://snapcraft.io/
> AppImage - https://appimage.org/
> We should evaluate these technologies in the next release cycle or so and see if any would be a good choice for RStudio Desktop (and in particular whether it'd allow us to simplify things or simply introduce a sixth variation!).
>I would expect there would just be like regular apps, or at least have some central management application or something.
The whole point of AppImage is that you don't need such stuff. Just download one file, set the executable bit, and run it. Has been working beautifully for a decade now until your commit broke it.
You can use either AppImage or the zip. How to use the signature file - just read down below on the download page. The signature file is optional, you download it and use it to verify that the binary (zip or AppImage) is legitimately signed by me/us.
An AppImage behaves like AppImages behave, see:
(if you browse down a bit it says "How to run an AppImage")
The zip you can just unzip somewhere, and then run "canoe" inside it.
Depending on your taste you can use official repos (very limited), add specific vendor repos (a bit tedious to search), <code>opi</code>, Flatpak (e.g. via Flathub) or <code>AppImage</code>. Hope this helps and welcome to openSUSE. :)
You have a lot of options. Here are a few:
- To distribute through a package repository, like Canonical's
apt, Debian'sapt, RHEL'srpm, etc. Go to that linux distribution's website and look for instructions on how to get your package added to their repository. - To package in a file that people can download, look into .deb and .rpm files. This method of distribution is still somewhat distribution specific. You may need to package differently to support RHEL, Ubuntu, and Debian.
The above two options suck, yes? Here are some better ones.
- Look into appimage. This kind of packaging should run on almost any distribution. It is possible to write app-images that integrate with many common menu systems, such as the ones included in XFCE, KDE, and Gnome. The user needs only to download the app-image, make the file executable, and run it.
- Look into FlatPak. This is a new packaging system invented by RedHat and used by many people. In theory, a FlatPak will run on any linux system. Most flatpaks are hosted on FlatHub, but there is the option to run your own repository if you want to.
- Look into Snap. Snap is Canonical's distro-agnostic packaging system. It is a lot like FlatPak, but only Canonical can distribute snaps. No one else can run a snap server, because the existing snap server is closed-source and the snap API is not yet really stable.
Those are the big options. IMO, app-image or flatpak are the way to go.
that downloads an .appimage file. You just chmod +x whatever.appimage then run it ./whatever.appimage
rename it to be whatever name you like if you want. https://appimage.org/ has the guide, and even a video for this..
My Guess is - its an appimage electron app - that just wraps up the browser and goes to the site.
Googling for krunker appimage finds --> https://old.reddit.com/r/KrunkerIO/comments/ev8usi/how_to_install_krunker_on_ubuntu/ which mentions an issue another user had 2 months ago. do not run the appimage as root.
I've had exactly this problem when it comes to distributing Climaxima. This application is very complicated to build due to a large number of dependencies, so I can't just create a binary.
Currently I use two methods: Appimage and Flatpak. These solutions allows you to distribute the application and all dependencies in a self contained package.
Appimage: https://appimage.org/ Flatpak: https://flatpak.org/
Since the build process of Climaxima is quite complicated the build scripts are much larger than your typical application but you might still find something of interest in them:
Docker is used to build the application, but it's not run using Docker: https://github.com/lokedhs/docker-maxima-client
Linux is bad for games - Eh. Maybe you got a point. I don't play games. I know it's better than before we had Steam on Linux.
I can't do my work on Linux - Ah yes, Photoshop. The tools for dentists, mechanics, and of course lawyers. Not every industry uses Photoshop.
Ease of Use -
Installation - I don't think it's any easier to install MacOS or Windows. On most distros you can just hit the next button a bunch of times. The defaults are usually sane.
Distros - Might be weird if you use a obscure version but most major distros are using Gnome or Xfce. Both are solid.
Terminal - If you use a distro link Ubuntu or Fedora you got the Gnome desktop. Everything is doable without the terminal. You're not gonna have a good time with an obscure distro.
Repos - You need some portible apps? Try AppImage. I run AppImages from a thumb drive all the time.
Permissions - Again. As long as you are using a modern (not obscure) linux distro you don't have to worry about permissions to change themes. Just drop your themes in the
.themesfolder. It's painfully easy.
The Short
> Until users and contributors stop clinging to the terminal as the main means of doing anything on Linux, until then it won't become attractive to normal people.
There is a reason why Terminals are on both MacOS and Windows (Powershell anyone?) is because a lot of us use terminals for our jobs.
portability is a valuable feature, since allows easy cross-compilation for other platforms and archs, permits convenient transferring of installed program files/configs to another computer of basically the same architecture, in some cases allows building lone-standing meta-packages including all required dependencies, libraries and headers (see AppImage), induces sharing of code, new ideas, improvements, bug reports and fixes among developers and users of different OSs cutting down the time required for software to be ported and updated for all the supported platforms, making it easier it to port open source software to platforms/OSs where this software is not available yet
These are motly the reason which analogue projects like pkgsrc and nix have earnt their own discrete success throught years and are still pretty much alive
Yes, you could indeed compare just the Sha256sum digests. However, for some reason unknown to me, people generally prefer to compare the full files, but you are right that a hash comparison would also do the job perfectly fine.
By the way, you assume that the package is a self-contained executable contained in one single file. It is indeed possible to merge all application files into one single executable with tools such as https://appimage.org. The electrum wallet is indeed distributed like that on the author's site.
If you verify the signature of the self-contained executable after download, and you are also ok to be a guinea pig for the new bleeding-edge version of the wallet, you can certainly proceed like that.
However, most users are simply too lazy to verify the package's signature after download. That is why we advise them to use the system-wide installer instead ("apt-get"), or its user-friendly lipstick user interface (GUI), which will automatically verify the signature for them.
An ordinary user should probably not make a habit out of side loading the app directly from the author's site and bypass the app stores.
You can do that but that is only safe if you manually carry out the security procedures by yourself. Since every distro runs its own app store, if you do not like one distro, then move on to another app store.
For example, Arch Linux is also rapidly closing in on the 100% target for reproducible build of all its packages. It is therefore a legitimate alternative to Debian which also still has a 1250/51000 = 2% shortfall of packages that still do not satisfy the reproducible-build engineering standard.
As long as 100% of the JEOS footprint ("Just Enough Operating System") can be reproducibly rebuilt and audited, the small gap of 2% of non-critical packages is not an issue, especially, since you are not even supposed to install these (usually obscure) shortfall apps on a security-sensitive machine running important financial software.
Not necessarily for proprietary software …
> On linux there's snaps and flatpaks, …
… and AppImage | Linux apps that run anywhere
Work in progress:
an .appimage has nothing to do with apple.
it is a self contained executable.
just like the old in the old windows
days of having 'programname.exe'
make it executable , then run it.
full details at...
You could use appimage: https://appimage.org/
But overall you should probably think about more...
- how will updates be handled
- what will the customer need to do, he still needs to set up raspbian
- maybe you can use Raspbians packet manager and submit your app to an app store. So you have an update distribution mechanisms + security already and don't need a lot of manual work
I'm not sure what you think I'm pretending. Your problem has nothing to do with the OS. You are making it look like OSX is issue free, which it is not. Each time I upgrade my OSX version everything gets broken, my brew installation had to be reinstalled many times because of that. These are just software issues.
If your app needs libcurl3.so then you can easily bundle your app with it, and either use LD_LIBRARY_PATH or LD_PRELOAD. Takes 2 minutes to fix that. Ultimately if your vendor doesn't provide proper packages that's their fault, nowadays they can even simply provide .appimages.
The download is provided as an AppImage. You need to activate the executable permission bit on the downloaded file to be able to run it. Right click on the file, Properties, Permissions, Allow executing file as program. After that, you can double-click to run it.
was looking for a Flatpack of this and found none. I did find an appimage package which is a similar packing system.
https://github.com/darealshinji/mkvtoolnix-AppImage/releases
learn how to use appimages here.
If you want to package the app for linux then you can build a Snap, Flatpak, or AppImage. Snap and Flatpaks would require you to submit it to their repos but AppImage would be like a windows exe where you can just download a single file and run it. You can find the appimage website here. Instructions for packaging your app can be found here. Also this page has better instructions for building an AppImage.
Good work BTW
Snaps aka Snapcraft is one of many ways to package an app for all Linux distros with just one build and not needing to compile it for every distro (think of similar things like appimages or flatpaks). They aren't really that good and if possible you should find some way to avoid using them.
I copied this from appimage.org
>The key idea of the AppImage format is one app = one file. Every AppImage contains an app and all the files the app needs to run. In other words, each AppImage has no dependencies other than what is included in the targeted base operating system(s).
So yes.
You can have a look at AppImages. Essentially a single portable binary (like a .dmg in Mac or those PortableApps in Windows, but it's just one file). No need for creating several packages for several distros, it's all self-contained, you just mark it as executable and run it. Recent emulators like RPCS3 and Yuzu provide AppImages for Linux, so if you're feeling like it that could be a good start.
It's definitely not a hassle. The only hassle is around if you intend to add it to your package manager. A package manager is something that Windows just doesn't have.
There's AppImage that runs anywhere, this is essentially an .exe you would use on Windows. There's also Flatpak which containerizes each application (including its permissions!) to isolate it from your system.
Either of those systems (ubuntu also has their own version of flatpak called "snap") works perfectly fine for the average user. It's only when you want these random apps to get automatic updates from the developers where you have to go adding new sources to your package manager's repositories. Once you do it once, that's frankly the easiest task in the world -- and again, it's perfectly optional.
Spyware discord lmao. Run it on a vm on your main distro if you don't want it to take data about your comp. Idk about the browser app tho.
Your post reminds me of reading the arch wiki. The feeling of your brain melting then getting blended into a milkshake. Well, go for pop or other ubuntu distros if you want to not have headaches, since they are the most well supported. If you search for the ubuntu fix for this problem, it will most likely apply to ubuntu derivatives as well as distros based on ubuntu. There are a lot of tutorials regarding ubuntu basde and the apt manager over any other.
You can try arch with an installer script like archfi which simplifies things to install a ton.
my recommendations: Ubuntu gnome, Mint cinnamon, Popos, elementary os.
You can install popular desktop managers in ubuntu based os's. If you are going to use ubuntu gnome for example and want to install kde plasma, just use kubuntu instead.
PS-This makes not relation, but check the leading linux distros tab in the appimage format website: https://appimage.org/
They must be the most popular distrobutions to be supported by a format as widespread as appimage. Try em out. The best to try out are the ones that come with live installs imho.
There are actually quite a few... But many are not what we might think of as serious applications, though quite a few are.
I do not know if this list is comprehensive, of course.
appimage.org also mentions several which are, perhaps, more notable.
As someone on the audacityteam thread mentioned, Linux users are somewhat at the mercy of their distro unless they want to joust with building from source.
I see that flathub has it, so may give that a try.
I'm not intimately familiar with the internals of appimage vs flatpack, though I believe I have seen comments favoring appimage, so we'll see!
Thanks.
I think you probably read my old thread asking about this . I think the most versatile way would be for them to release an Appimage which is cross platform for all linux distros. I run Prusaslicer as an appimage since the latest updates to PS seem to take awhile to hit the Fedora repos. I'm unfamiliar with how to create an appimage but think it's just a matter of wrapping your existing build into the package https://appimage.org/
I'd love to dedicate an RPi4 to DDCut and run a small 7" touch screen to navigation.
Have you followed the instructions on the AppImage website - https://appimage.org/
For Kdenlive it would be:
chmod a+x kdenlive-20.12.3a-x86_64.appimage
And then:
./kdenlive-20.12.3a-x86_64.appimage
This even applies to windows to some extent.
Programs can be in any place on the filesystem, but the system looks into a list of folders that are called "system path". Go into bash/cmd and run echo $PATH. you will see that list. in linux it will usually contain /bin, /sbin, /usr/bin, /usr/local/bin and other folders containing bin on the name (bin stands for binary, not trashcan). When you install a program via apt, it grabs a .deb file (which is just a zipped folder with a specific set of files and folders on it) and then copies the pertient files to the pertinent folders. Becasue Linux is a modular system a program can detect if a librariy or other required program (this are called dependencies) is installed, and avoind having copies of the same thing (looking at you redistribuitable .net)
if you type the name of a program into a terminal it will attempt to search it on the folders listed on the path variable. if it fails, it will show "command not found" or something like that.
Note that having a program in a path isn't obligatory to run it. you can simply type in the comand line /path/to/the/program and it will run. That might be your first method: having them on the other drive, and run it mannualy typing the full path.
The second one is to set up your drive in the path variable, and configure the system to automatically mount your drive on that folder when connected (in case you don't know, in Linux there is no C: D: or any letter drives. subsequent drives are mounted inside empty folders on the main system drive).
The third choice is that we have portable apps. they are called appimages: https://appimage.org/
Snap doesn't come pre-installed with Tails, but is in the Debian repo, so yes, it's doable.
There are some downsides tho. My understanding of snaps is limited, but if I got things right, snaps are not portable in that sense that you're just copying over the binary to your home and run it, but are needed to be installed to /var/lib/snapd/snaps.
Due to Tails being amnesic and your package not being in the Debian nor the snap repo, the package has to be manually re-installed each boot, means, the user has to login with admin password enabled.
Because your package is not signed by canonical, the snap --dangerous option needs to be passed at install, which will likely will disturb users.
I think you may want to look at AppImages. You can even provide desktop integration and updates. Have a look at their documentation on how to build.
Another option would be guix --pack.
Both options will bundle all dependencies and could be easily run from the Persistent, without further adjustment needed.
A little offtopic, but since you meantioned snap, ...
You might want to have a look at AppImages (https://appimage.org/) they are (IMHO) a better way to distribute Applications than (DEB's, and other distro specific Packages)
Sadly, Firefox and Chromium do not yet have an official AppImage, yet.
<shameless plug> Untill then i setup a little github repo with a CI which regularly builds and releases the latest Chromium version. If anyone is interested.
https://github.com/igorlogius/chromium-browser-appimage </shameless plug>
And since you meantioned that you dont trust any package you can not exam, you can extract the content of any AppImage simply by appending the
"--extract-AppImage" argument. That will give you a folder squash-folder with all its content.
I just looked again at the download page... and it seems you are downloading the wrong thing.
Click on the LINUX 'box', then select 'portable'
THEN it can download a PureRef-1.10.4_x64.Appimage file
You make that file executable, then Run it.. (you can rename it if you want)
$ chmod +x PureRef-1.10.4_x64.Appimage $ ./PureRef-1.10.4_x64.Appimage
https://appimage.org/ has details, and guides, and videos on how to run an .appimage
Have you considered making your linux executable an https://appimage.org/? I always felt that appimages nature would make it great for games but never see it get used as such.
Not sure if you're going to find something cross-platform but for Linux you might want to try AppImage - https://appimage.org/
To summarize: Linux: FPM, AppImage macOS: DMG, brew Windows: MSI, chocolatey
You can download the app from the terminal with wget with
wget https://mail.tutanota.com/desktop/tutanota-desktop-linux.AppImage
Then you need to make the file executable
chmod a+x tutanota-desktop-linux.AppImage
And finally run
./tutanota-desktop-linux.AppImage
You can find more information about appimages at https://appimage.org/
Did/can you try changing the file to executable before opening? That's what https://appimage.org/ says to do (and it doesn't seem like anything we do can remove that step, though it's super annoying and we should document it).
Did/can you try changing the file to executable before opening? That's what https://appimage.org/ says to do (and it doesn't seem like anything we do can remove that step, though it's super annoying and we should document it).
So far after trying out solus for around a month literally the only downside I've found is that it's repository isn't as comprehensive as arch or debian based distros such as manjaro or ubuntu/linux mint. It does however support AppImages out of the box just like ubuntu and Bitwarden for example that wasn't found in solus' repository provides an appimage.
Steam Sky - Roguelike in a sky with steampunk theme
Steady, busy week, almost like usual:
- Another bugfix release of stable version of the game. By whole week no bug or crash report. This may mean one thing: nobody downloaded it :) Only one bugfix ported from development version but probably that problem will never happen in stable version.
- Work on themes system continued. And I hope finished it for some time. Now it is possible to set all "icons" in game.
- Some balancing changes: good for players: waiting in place outside bases uses a lot less fuel than earlier. Bad for players: overloading will now trigger faster than earlier. Simply it will be impossible to fly with lowest speed with fully loaded ship on one, not upgraded engine.
- Development version got some new NPC's ships again.
And at the end, the question. I started inspecting AppImage as distribution system for the game on Linux. And I must say I love it :) It is very similar to .dmg files on MacOS, clean and simple for users and developers. Thus question is: maybe someone know something similar to this on Windows? I was trying to find it, but my google-fu was failed me. At this moment shipping the game even as the installer on Windows looks for me very not user-friendly :)
The first thing you need to understand is what Linux is NOT windows
Furthermore there are AppImages which is a project to bring something as close to portable executable files to Linux, although there aren't that many developers who use them at the moment
Indeed, that is unfortunate! In the future, we will provide standalone binaries for Linux using https://appimage.org/ so that should hopefully make it much easier for everyone to use the latest version of Electrum.
Not really.
The original root of most operation systems is Unix. Here's some quick gaming-related OS family trees off the top of my head:
Unix->BSD->FreeBSD->Orbis OS (Playstation 4 os) Unix->BSD->FreeBSD->Darwin->macOS Unix->BSD->FreeBSD->Darwin->macOS->iOS Unix~>Linux (linux is a re-implementation of the unix interface. There's some history there that doesn't matter) Unix~>Linux->Android Unix~>Linux->SteamOS
and then over here screaming in the corner about how special it is we have: Windows 9x->Windows NT
Windows is actually very much the odd one out implementation-wise, but it obviously has a lot of inertia in the desktop games industry. Saying that linux doesn't support most games is straight up wrong though. Some quick stats googling suggest there's ~2.3 billion android devices in the wild to 400 million windows computers, so linux definitely supports games fine.
The primary problem with releasing games for linux desktops is not compiling, which even the big engines like unreal have done out of the box for around 5 years now, but packaging for all the various slightly different distro variations out there. Tools like appimages can help with this a lot. In addition to clever packaging solutions, most linux game devs only guarantee support on specific distros, usually ubuntu, to simplify their distribution mechanisms and support costs.
In any case, I've been gaming on ubuntu with no windows machines at all for like three years now and I'm happy as with my setup. You couldn't pay me to go back to windows.
Native executable? .NET It seems to be a PE-32 Windows executable that requires the Mono runtime to run. So, it is not a native executable at all, but it could be turned into a truly native executable by packing the .NET app with Mono runtime using https://appimage.org/ On Windows it doesn't need any dependency because .NET is already installed on Windows by default.
The .net executable could be bundle with Mono runtime (.NET VM for Unix-like systems) with AppImage system. Many Linux applications such as KDevlop IDE, QT Creator and so on are using this tool for distributing self-contained executable without any dependencies.
None of these are real concerns today, let's talk about why:
1.) There are formats like AppImage that run across all modern distributions by allowing you to distribute your Linux application along with its dependencies. I've been involved in projects like Krita that have no problems distributing software across Windows, OSX, and the entire Linux ecosystem.
2.) The Steam Linux Runtime creates a run-time environment with bundled dependencies. If your system can run Steam, it can run Steam Runtime games.
3.) Finally, developers can limit their official support to a single, popular distribution, like Ubuntu. Support Ubuntu and advanced users of other distros often figure out ways to get it working on their systems. Not ideal, but better than nothing. Nobody wants or expects developers to test on every possible distribution.
Basically, this breaks down to the old "fragmentation" argument, which has been mostly solved for the last decade. If your last experience with Linux was more than 10 years ago, then I think you'll find that it's a much different ecosystem than it was back then. It has its flaws, but many of the problems that I've seen stated recently are overblown or generally false. Windows and Mac are just as inherently flawed as Linux, in my opinion.
Ok, you can also apply this patch to save yourself some time :) https://gist.github.com/dbrgn/e18d3916e9ffbc8b6cc95f8f73e95251
Regarding packaging, take a look at AppImage (https://appimage.org/), it might be exactly what you want since it allows packing assets and even libraries into a single executable.
This might be different for Rust based projects due to more robust error handling (especially if you use pure-rust libraries).
If you link against dynamic libraries you may still have issues, but then you can simply document the required libraries. Or create an AppImage: https://appimage.org/ (Haven't done this for Rust projects so far, but it works great for https://librepcb.org/)
TarBalls are....ok? Is there an executable file format that works on BSD? Similar to AppImages or Flatpak? Not necessarily universal just easy to use? Do BSD operating systems have something like .deb files?
I agree that every application needs a tar ball but, I still feel like they are a pain to use.
Rasbpian is related to Debian, and according to the main webpage, Debian is supported. This means it should work on raspbian.
As for Cura specifically, everything points to just using OctoPi. You may be able to compile Cura yourself, but AFAIK nobody has been able to successfully build it for a raspberry pi.
It is probably a better idea for upstream projects to streamline their build and contribution process instead.
Also, for Linux applications that can run on any distribution, AppImage is worth a look.
AppImage, in contrast, doesn't use "runtimes". This is why you can download LibreOffice-5.2.0.beta1-x86_64.AppImage, chmod a+x, and run it without any special preparation of the target system. Which means that it will run on any not-too-outdated desktop Linux distribution.
This also works for KDE applications like Krita (which released 3.0 with an upstream-provided AppImage), but it means that either the KDE libraries must be assumed to be present in any of the targeted distributions in a recent enough version (which cannot practically be assumed), or that they have to be bundled along with the app (which is what AppImage is doing). Flatpak, on the other hand, tries to enable dependencies to be be shared between multiple applications, effectively creating another layer of dependencies and a "meta package manager" on top of the regular package manager.