This document has info about the RFS2 Engine used in RFS. You may also want to visit the RFS/Retro FPS Studio website.
The so-called "RFS2 Engine" is, like other game engines, the underlying code framework enabling all visuals, physics, and audio that in summary make up a game. Like some games use e.g. the Unity engine, RFS/Retro FPS Studio uses the RFS2 Engine. This FAQ document is provided for those curious about how that engine works.
RFS2 Engine is not based on any other engines. It does, however, use some helper libraries that are integrated into its executable file. All level handling, collision, and graphics rendering is custom, inspired by authentically old restricted 3D/2.5D first person engines originally written for the MS-DOS operating system. RFS uses similar techniques to replicate visuals down to characteristic render quirks.
The graphical capabilities of RFS2 Engine are closest to the original DOOM engine and Build engine, with some more advanced features alike to e.g. the later Lands of Lore 2's 2.5D engine. In terms of collision physics, scalable UI, and resource limits it is more comparable to a modern engine. Its core was programmed in C, while the program logic and UI of Retro FPS Studio use Lua.
The RFS2 Engine has dramatically lower system requirements than most modern game engines. While it won't run on old DOS machines, it will likely run on most ten year old laptops, desktops, and many single-board Linux computers, and even on Windows XP SP3. Due to relying on retro render techniques, it doesn't need advanced hardware features.
RFS2 Engine's render technique is a half raycaster, half portal renderer hybrid, fully done as software rendering without reliance on OpenGL/Vulkan/Directx or the like. This results in characteristic visual quirks, alike to the original DOS 2.5D games where most were also software rendered. It also comes with limitations, RFS being somewhere between the DOOM and Build engines' limits, with for example no movable walls allowed ingame (which Build allows and DOOM doesn't), but no map preprocessing being needed before playing (which DOOM requires, and Build doesn't).
Adapting an old-school rendering approach and design for beautiful retro games, RFS2 Engine inherits many of the creative limitations. This is meant to boost your inspiration and keep things simple.
The following limitations for all ingame maps are inherited from DOOM/Build/... and alike:
Only upright walls and flat floors are supported, as in the original release of DOOM for MS-DOS. Walls can be any horizontal angle, but slopes as seen in the Build Engine are not possible. Any floor or ceiling must be flat.
Rooms can only vertically overlap under specific constraints. In general, RFS2 Engine's rooms, which are the equivalent of DOOM/Build's sectors, can be flexible polygon shapes. But two wall openings directly above each other are impossible since there is only limited Room-over-Room (RoR) support, comparable to early Build engine versions.
Basically, rooms can be above rooms via RFS2 Engine's room layers, but they can't have any direct vertical connection. While there are additive 3d blocks in RFS, these are restricted in size and not as suited to form full ceilings as the common "3D floors" of modified DOOM ports. However, original DOOM for DOS didn't allow this either.
(Note: if this all sounds confusing, don't worry. You'll get used to it once you play around a bit with the editor.)
All movable objects must be 2D sprites, with the exception of doors and elevators. Walls cannot move ingame, they can however be moved with realtime preview in the editor.
There are hard limits on overall map complexity, some because it simplifies the engine code, others to ensure acceptable performance for most players. However, the editor generally tries to communicate these limits when you hit them and stops you, avoiding glitches or crashes.
An example of a limit is the maximum amount of rooms per room layer, and the maximum amount of room layers per map. Don't worry: since the total limit on maps per game is four digits high, and doors can connect multiple maps, these complexity limits shouldn't impact your overall game world size too much if you plan to go epically giant.
Lighting is limited to a flat per room value with simple dynamics lights with shadowless falloff on top. There is no dynamic shadowing, no baked shadow maps, no physically based rendering, and the dynamic lights are also not pixel perfect. With this, RFS2 Engine's lighting is in the same ballpark as later more advanced 2.5D first person engines from the MS-DOS era, like the one of Lands of Lore 2. (The earlier simpler engines, like original DOOM, didn't even allow any light falloff.)
There is no fully unrestricted six degrees of freedom rotation for the camera due to how the rendering works. Therefore the engine is unsuitable for games like Descent, or Forsaken. This again mirrors how DOOM and the Build engine work, being 2.5D.
Similarly to the old DOOM engine, walls are rendered in raycasting style with vertical slices. Therefore, looking up vertically uses vertical Z shearing with its recognizable perspective distortion. This was an intentional decision.
This is because all rendering is done on the CPU/the main processor, also see here on RFS's software rendering. This is how the old DOS games worked, but it does have the side effect of higher CPU usage.
Being based on nowadays unusual retro rendering techniques, RFS2 Engine exhibits characteristic visual oddities. Many of the original DOS era or PlayStation 1 games had these quirks too, giving RFS a very recognizable look.
No. Due to how raycasting and portal traversal work, rendering performance depends mostly on just what's visible, not on currently invisible map parts. This menas RS2 Engine has rather good occlusion culling.
However, more characters, objects, and enemies will still cause some slowdown, since they may need behavior or physics processing even when not visible. A larger level may also slow down the editor somewhat.
Since the GPU isn't touched except optionally for upscaling of the final output image, the GPU is quite irrelevant. RFS2 mostly bypasses the GPU.
The main improvement of RFS2 Engine is its modern integrated editor, allowing instant build and play married with an authentic ingame feel. Making retro FPS games has never been easier! On a technical level with being a modern code base, RFS2 Engine also does away with some common DOS game limitations.
Most notably, RFS2 Engine removes the following limits:
The usual retro engine editors often allow making maps where the original engines crash, or badly glitch. Due to better scalability and tight editor integration, RFS2 Engine mostly avoids these pitfalls.
Most old retro engines render in 8-bit with 256 colors, requiring dealing with palettes. RFS2 Engine works with somewhat universal but still retro looking 16-bit/4096 colors everywhere, with cozy quantized lighting. This gives lots of retro-style color banding without the same level of headaches found in palettized engines.
Unlike original DOS games that need a 4:3 aspect ratio, RFS2 Engine allows almost any ratio. Resize as you wish, portrait mode works too, and it's never distorted.
Both the editor and games have touch support, and games have out-of-the-box gamepad support. There is also proper mouse aim.
Most other authentic retro engines, e.g. the DOOM and Build engine, are offered under GPL licensing, which may complicate things like selling games. RFS2 Engine is a clean rewrite without GPL code. (Note: If you want more flexibility and challenge, and you don't mind the GPL, these modern engine ports might interest you. Check zdoom.org out.
Unlike modern DOOM engine ports, RFS2 Engine has a single glorious retro renderer, and not multiple with different feature subsets. Players won't easily run an incompatible version that glitches with your maps/games, and they won't need to tweak compatibility settings.
RFS and RFS2 Engine are currently proprietary, but most of the code can be reviewed under restrictive licensing. It is not allowed to be used for derivate projects or forks, however.
The code base of RFS2 Engine is actually written to be macOS ready in most places. However, Apple bans use of their system SDK via cross-compilers on Linux, and it bans affordable use of macOS in local VMs. Since RFS2 Engine releases are built on a Linux machine, this makes macOS releases impractical. Complain to Apple if you don't like this.
In addition, Apple has engaged in a couple of indie developer hostile practices, like making it near impossible for an end user to run unsigned programs while making signing for developers considerably pricy, or deprecating vital cross-platform APIs like OpenGL with no suitable replacement.
As soon as a macOS release is no longer an unsustainable technical and financial burden, it will likely happen. This however is unlikely to improve unless Apple changes its policies.
RFS2 Engine has a renderer that some would call 2.5D due to its visual restrictions. This is most apparent in the mapping limitations, and the limited up/down tilting via Z shearing. While all objects, physics, and gameplay handling is true 3D, maps are mostly 2D planes, although through layers there is limited room-over-room and advanced verticality support. So this puts it all in a cozy 2.5D spot. (For what it's worth, we think this applies to the original DOOM too, even though some call it "actually a 2D game.")
Like many old games, RFS2 Engine internally uses X and Y axes horizontally, and Z up. Modern engines tend to work with Y up. In the end, it's mostly a matter of preference.
By integrating a full custom MIDI stack (details here), RFS2 Engine removes most downsides of
.MID file playback like stuck devices,
huge sound differences on different computers,
MIDI driver problems, or MIDI output breaking fully.
So you get MIDI without the old-school headaches.
Music creation with MIDI is also very accessible and straightforward to use: most MIDI music software has lower hardware requirements than modern digital audio music software, so you'll find a working music editor even with a slow machine!
While MIDI music may sound simplistic it is authentic for the era,
and alike to RFS2's map limitations the requirement to
keep it simple will both tickle your creativity, and give you
a result lovingly close to many DOS retro games.
And there are huge libraries of pre-existing
to be found online to boost your game making.
Summed up, RFS2 Engine supports only MIDI music because it's a good fit. And mp3 or such can still be used for sound effects.