Hey all,
Perhaps you can help me here. I am writing about "fantasy consoles" and I am trying to give some sort of formal distinction between the concept of "fantasy console" and a"virtual machine". Any input?
They are very similar concepts, the main difference is one of intent.
The short version is "Virtual Machine"="serious", used to implement high level programming language (JVM) or simulate a whole other system inside a host system (virtual box type virtual machines).
"Fantasy Console"="for fun" used to simulate a fictional games console for playing games on.
My 2c...
I think we would use the term Virtual Machine if the Pico-8 app we use on desktop appeared after some physical hardware version of Pico-8.
But there is no physical version, so therefore @zep coined the term Fantasy Console to differentiate
Yeah. You could call a fantasy console a "hypothetical machine" as opposed to a virtual one.
I would tend to agree with Matt's thought. By being "virtual" suggests is represents something real...tangible...where Pico8 never existed as such. I mean, in theory, MAME and the likes are virtual machines, right? They give us the ability to port physical abilities to our computers as just software.
I'd love to get zep's input.
I think that this stems from the old debate about "emulation" vs "simulation". One might say that a virtual machine EMULATES the exact functionality of a system whereas a fantasy console is a simulator -- that is, it doesn't pretend to be the real thing.
I guess think of it this way -- "goat simulator" doesn't replicate the functionality of a real goat whereas a "goat emulator" might.
But what of systems running on simulated (emulated?) architecture? Like android (ARM) running in a virtual box on an i7?
So confuse.
I'm not sure. I'd love the master's input on this.
I would compare Pico8 to a game engine or tool such as Unity, Construct, GameMaker, etc. The difference is that Pico8 was designed with intentional limitations to make games have a consistent look and feel that is more like an 8 bit console.
A fantasy console has much more freedom, which is what Pico-8 takes. An emulator needs to be at best cycle exact to real hardware, using all the hardware related restrictions. The restrictions of Pico-8 on the other hand are more to drive creativity. Pico-8 has 1MB of memory for the lua scripts, which is far more than any 8 bit machine ever had. It features dynamic memory allocation, it features a frame buffer approach and much more.
@matt, What about the JVM? That's a virtual machine which was never a physical machine first.
If it existed in hardware first and then was ported to other platforms we'd call it an emulator.
There's a more technical definition of "virtual machine" that involves running a guest operating system (e.g. Linux) within a host operating system (e.g. Windows), where the guest operating system gets to use the native hardware as much as possible. The guest OS runs real CPU instructions compiled for the native platform just like it would if it were the native OS. In that context, console emulators are strictly emulators and not virtual machines. This definition is prominent enough in tech/IT that I would not describe Pico-8 or console emulators as "virtual machines" in, say, a magazine article intended for a general audience.
You could almost say that Pico-8 is like an emulator for a console that never existed, though again to be technical it doesn't quite do what an emulator does, as SunSailor mentions. It does not have a (developer-accessible) machine code running on an emulated CPU. It runs Lua code in a natively compiled Lua interpreter (which does some bytecode behind the scenes), and it has features for sync'ing the program to a frame timer. The addressable memory region is a fun throwback to old platforms, but you can't store or execute machine code in it, so it's just a data structure.
Re: the JVM, despite the "VM" in the name, the JVM is in a grey area with this definition of virtual machine. It sometimes compiles bytecode to native code, and is otherwise a bytecode interpreter. You can compile to JVM bytecode from many things besides Java and run it in the JVM. Pico-8 does not expose the Lua bytecode interpreter and only takes Lua code as an input. At this level, Pico-8 is just a Lua interpreter with a funky graphics and sound API.
@mrh touché! Good parry.
What @dddaaannn says
IMHO
Virtual Machine = software that simulates a system and uses parts of the host hardware.
Emulator = software that simulates a system and its hardware.
Thanks for the thoughtful answers, all!
There seems to be a distinct difference, though, between -- say, Notch's dcpu-16.
The DCPU, I know, works on a very low level and emulates a complete system (or something like that). The PICO, while it DOES give you a basic environment -- from what I understand -- does not run at the same level of abstraction.
Whew. Brain hurts.
VM, OS, Fantasy Console, emulator, Game Maker Software, Interpreter....they're all basically the same thing; they run code identically as possible on as many machines as possible. The intent and how 'close' the hardware it gets is really the only differences. They're basically on a sliding scale with OS on one side and Game Maker Software on the other. Fantasy Console falls somewhere between VM and Game Maker Software.
Hopefully that is clear as mud.
SCALE OF 'VMS' = OS, VM, emulator, Interpreter, Fantasy Console Game Maker Software
The main thing is it's all for the sake of running code on more than the machine it was written for without having to do much specific porting of the different programs, which tend to be what the 'end user' makes. i.e. you don't want to rewrite display code for every possible machine, so the VM takes care of that so you can just focus on writing a system that displays cool artwork you calculate with simple math about where to draw lines without worrying how much power to give the GPU and how much cycles to split between other processes or whatever.
Despite the fact that this question seems to have been solved before, I'd like to make an addition.
Virtual Machines take real software/systems and recreate it within your device's environment.
Using that definition, Virtualbox, almost every single console emulator(examples: ZSNES, Gens, or Mesen), and DOSBox can be classified as a Virtual Machine.
Fantasy Consoles/Computers try to simulate the limitations and/or style of old devices for use in your device's environment.
Using that definition, the HCGE, pico-8, TIC-80, and many others can all be classified as a Fantasy Console.
I hope this clears it up.
A virtual machine like the JVM executes bytecode (a series of encoded opcodes); thereby, simulating physical hardware (CPU, memory, etc).
PICO-8 has a memory model which is well defined; however, I don't believe it is processing virtual instructions (might be wrong about this). Meaning, the actual computation is higher level and is encoded via Lua instructions.
In this way, PICO-8 is kind of simulating an interface built on some lower level OS where there's a boundary between the lowest (simulated) machine level and the UX.
The fact that you can't write PICO-8 assembly language, but you can write raw instructions for the JVM, Erlang (OTP), and a host of other virtual machines is a pretty defining difference.
[Please log in to post a comment]
