How do you load Aminet packages onto a physical Amiga? In FS-UAE the file system was fully exposed to Linux and I could just extract packages that way.
I have the Amiga hooked up via serial port to my linux fileserver via one of these USB-to-RS232 dongles. The fileserver has a tty session running on the serial port. With a terminal emulator from the Amiga then, I can just normally log into and navigate the server. Bidirectional File transfer you can then do via kermit or zmodem inside the terminal session. The fileserver has a local mirror of aminet. Transfer isn't fast via the inbuilt Amiga serial port because it's not a real UART and basically works by CPU polling, so it's very CPU speed dependent and intensive. There's clockport serial adapters with proper UART which are a lot faster and less CPU bound, and there's also PCMCIA serial cards (these need to be 16-bit, not later 32-bit ones). You can still get them cheap because everyone nowadays tries to get their Amiga online via network card and TCP/IP stack to browse the web very poorly in order to read their social media brainrot because the other 12 hours of the day where they already do that are apparently not enough. There's also a cool project where you can turn an ESP32 microcontroller into behaving like a hayes compatible modem with wifi and TCP functionality and a few extras that improve connectivity. The ESP32 of course handles this exceedingly well because the ESP32 CPU cores are much faster than any real 68k - up to and including the 060 - ever was. I feel these serial methods are more time-appropriate and just work all-around better. (more software properly supporting it, less heap of 3rd party hacks)
For bigger files the faster method is CF card. You can get PCMCIA to CF card adapters on aliexpress for cheap. I have a bunch of CF cards lying around, but you can also get CF card to SD card adapters. For the Amiga there's "Fat95" which enables it to read and write FAT32 file systems. (Linux still can read the Amiga's FFS with the proper kernel modules though) You can then just normally format the card in your card reader, copy files to it, insert the card into the Amiga's pcmcia slot (only the A600 and A1200 have those) and mount it as drive. It usually works well enough and is pretty fast if the Amiga is a bit accelerated. The pcmcia slots can be a bit buggy without proper patches and/or hardware fixes applied. Most instability issues you read about online are the result of people not knowing what they're doing or poorly maintained devices in poor condition though (e.g. bad capacitors, incomplete/low quality repairs, unsuitable power supplies etc.).
The Amiga is in a nice sweet spot where it's still a simple system you can fully understand in detail (because it's just that well documented and Commodore was also completely open about the hardware design, technically it is proprietary but might as well be open hardware in how well documented every little quirk and register is - no black boxes) but is yet still much more performant, "modern feeling" and user friendly than other systems from that time, to the point where it's not a jarring or unpleasant experience to use it for productivity tasks (that are time appropiate). I use it for writing and pixel art and it's a very smooth and distraction-free experience. Vim also originally started on the Amiga, btw.
The interesting thing about emacs is elisp and the scope and depth of the self-documenting behavior. In emacs, you can simply write a function directly into any text buffer and evaluate it with ctrl+x e. You can extend emacs on the fly and develop new functions and expansions, just like that. Without turning this reply into a book, (e)lisp and emacs is very accomodating to rapid development like that and it's very trivial to test your code in tiny pieces in a very interactive way. Overwriting older functions with newer versions (while you are developing them) is really that trivial. Just change the code, ctrl+x e again and they're replaced. Want to know what a function does? ctrl+h f. Want to know what a variable does? Ctrl+h v. You can also directly jump to the lisp source code of any given function and then just copy it into a different buffer and modify it, overwrite it, attach new functionality to it, without ever reloading or restarting anything. You can extend, develop and debug emacs from within emacs while it's running. It's a very quick and satisfing way to program and extend emacs and in general to interact with your computer, if you are a programmer. I attached LLM functionality to my emacs, for example, and the code for that has grown organically with my needs/understanding of LLMs.
That said, a lot of things in emacs like the picture viewer don't work as well as standalone programs, alone for the fact that emacs is single-threaded and elisp is relatively slow. It makes sense to take simple external programs (e.g. for images, sxiv) and make wrappers in elisp around them.This is why some people like to control their entire computer from within emacs, because it's all seamless and very flexible. That's the difference between a text editor with a scripting language like vimscript, lua etc. attached, and something like emacs, which really, makes the most sense to be seen as kind of an interactive lisp VM/application framework (this incredibly flexible and interactive REPL is a feature of many lisps and is found in many lisp implementations, lisp basically runs as an "image" which state in many implementations you can save and then reload at a later date to interact with. Another langauge that pulls this off conceptually very well too is Forth). There's been attempts to make a more modern, technologically capable version of emacs using better implementations of lisp and also doing away with the considerable (inflexible) C base emacs has, but they all fall flat in one way or another. (The current iteration of this attempt is "Lem", and it falls flat because it doesn't seem to take the importance of "self-documenting" serious.)
What a long post. Thanks for reading my blog.
