Not in an emulator under Linux. As the only OS.
ISTM that even a $5 Raspberry Pi Zero should be more than powerful enough to run this well.
Raspberry Pi is a really nice (and relatively simple) hardware platform that would be great for running something like this and I have thought about it myself. Something like adding ARM [32|64] support to the kernel and then using an emulator of some sort to run 68k usermode programs. But I don't think FreeMiNT has ever been ported to any other architecture and imagine it would be a _huge_ effort.
The way Apple moved classic MacOS from 680x0 to PowerPC was to write a tiny kernel emulator, with an API to run native stuff on the metal, and run more or less the whole OS under emulation, profile it and just translate the most speed-critical bits.
https://en.wikipedia.org/wiki/Mac_OS_nanokernel
That's a lot of work for a FOSS project but given the performance delta between 1980s 680x0 and 2020s ARM, total emulation of the whole thing should be perfectly fine. It's how the PiStorm Amiga upgrade works.
https://amigastore.eu/853-pistorm.html
So all I envision is something like Aranym:
... running on top of Ultibo, say:
Or maybe Circle:
There was the idea to somehow port TOS to x86, but as we discussed it, the issues became clear. A native ST os on x86 couldn't run ST apps, because they're 680x0 code. And it won't run PC apps either, as they target PC OSes, not TOS/GEM.
Even if it's doable, it's a vast amount of work and there's no point. You still need emulation.
This is also why Apple ended up buying NeXT and switching OSes. Remember, Apple already had a UNIX: it had A/UX. But A/UX is a native 68030 Unix, with integrated classic MacOS. If Apple ported the underlying Unix to PowerPC, the embedded MacOS part that provided the UI wouldn't work, and MacOS apps wouldn't work. Without that, there's no point.
So Apple built a 68k emulator and ported the OS to the emulator. Then it speed-tweaked some bits. It worked and it delivered fast RISC Macs for a decade or more, which could still run old 680x0 Mac apps, but also allowed for new PowerPC apps to be delivered.
It was a good strategy, but it left them in a dead end. Copland failed, and so that's why NeXT, which was an excellent deal.
Well, honestly, we're not going to see any major new ST/TOS apps in 202x. It is not going to happen.
But there is this rather neat all-FOSS OS, or even pair of OSes: EmuTOS and FreeMINT. And they have apps, and programming languages, and are still vaguely usable.
So my thinking was: is there any way to glue together some existing code that enables them to run, providing an emulated 680x0 environment, on this cheap readily-available ARM hardware, without there being a whole other OS underneath?
https://github.com/michalsc/Emu68
To run 680x0 AROS (and maybe real AmigaOS via PiStorm) on bare-metal on the Raspberry Pi.
See:
That's tricky. My friend did this with the C64 (BMC64) by making VICE run basically as a unikernel on the Pi. It's a lot of work. There's payoff there for something like the C64 where latency is super important for video games etc. But on the ST, I dunno if I see the advantage esp if you're running MiNT etc.
If you mean actually running the OS sans emulation, like a port of TOS/MiNT to ARM; I actually started down this road many years ago, trying to port as much of EmuTOS over to native ARM as I could... and others have fiddled with it, too. But it's a huge endeavour with little payoff. There's no binaries to run, so you'd end up hosting an emulator in it, and the endianness is entirely different so it's just... awkward. I found the transition to 32-bit and little endian and totally different graphics hardware made much of the EmuTOS sources useless.
Take something like the AES. It uses 16 bit big-endian values throughout, hardwired into C-structs, basically. And this maps 1:1 with resource file contents. You either have to rewrite everything incompatible with ST-AES and resource files and use 32-bit little endian. Or you have to be constantly swizzling values back and forth. Or do both. Awkward.
Or the VDI that's written there. I actually made "ok" progress writing a fresh VDI from scratch for the Pi framebuffer. But then... what's the value? The API is not really compatible because word sizes, framebuffer depth etc. It just starts to look really anachronistic.
Better to just build something new.
Re endianness, I confess I hadn't even thought of that aspect of it. (I understand that Cortex-A processors can run in big-endian mode but I bet it's not that easy.) And I bet there are a million other things that would be hard to make work.
But I still wish EmuTOS/FreeMiNT could be made to run on a modern CPU. It makes me sad to think that the 680x0 architecture basically isn't going to go much further than the Apollo 68080 (or Coldfire...), whereas a modern ARM (or X86 or even RISC-V...) chip is stupendously more powerful and I'd love to be able to run those OSes on that. Oh well, I can dream I guess...
It's probably more reasonable simply to boot directly to a bare metal 68k emulator -- one that doesn't emulate any hardware other than the CPU but passes through to the underlying video etc hardware -- and host a fork of EmuTOS there.
There is also this project : https://github.com/kelihlodversson/pTOS
Which appears similar to what I had attempted, myself. Looks abandoned though.
You might also look at RISC-OS. It runs (single core) on a modern Pi. And it's kind of similar to GEM/TOS in terms of era and style.
It is kind of a shame that ColdFire is dead. It held promise.