Software rendering often provided better visual effects than the GPU paths could provide at the time. A general purpose CPU can technically do any effect since the software is the pixel shader.
Programmable shader pipelines weren't a thing until Geforce 3 in 2001.
Ah,Sorry,in 2001 it was actually the first, so Geforce 1 / ONE.
It hat -fasten your seatbelts- one(!) dedicated pixelshader and one dedicated vertexshader :-)
High times back then - it was like entering next dimension.
I really admire Woof[1] sourceport of DOOM and how it can achieve high fps at modern resolutions using software rendering (Sure, there are still GPU apis at work behind the scenes managing swapchain and all but rendering logic is still software). Also it's worth checking out for anybody who wants to see a good SDL3 codebase.
This isn't software rendering, it's called turning off spatial anti-aliasing. You can still do that in the modernest of modern games. Software rendering went out of the window because the CPU tends to have other things to do whilst playing the game besides only multiplying 4x4 matrices, which was shifted to the shader cores of GPUs. The look-and-feel that the author is discussing including shadow and texture LUTs can also be done on GPUs by passing the tables in to shaders as constant read-only storage buffers; that is not specific to software rendering. It bears mentioning that many modern software renderers (LLVMpipe/Lavapipe, OpenSWR, WARP) are basically full D3D/OpenGL/Vulkan devices in their own right, including shader compilers.
Also, modern spatial anti-aliasing works by multisampling within a pixel (or even neighbouring pixels) and taking the average, rather than filtering across singly-sampled pixels, which massively reduces the quality. Not to mention temporal and machine learning AA techniques including DLSS, XeSS, FSR, and all the TAA implementations in many games.
In a software-rendered game, the CPU draws every pixel. There’s no 3D card involved: the game works out each frame in its own code and writes it straight to video memory
I think that’s the standard definition. If you mean that this style can be achieved with graphics hardware then that’s a different argument and why your first sentence is deemed contentious
> If you mean that this style can be achieved with graphics hardware
I really ought to have been more specific with my first sentence to ward off any hair-splitting.
The author claimed to love software rendering, but the examples given to highlight the supposed positives of software rendering can all be achieved on GPUs. If the author had instead highlighted the ability to easily debug and inspect the inner workings of the rasterisation pipeline with a software renderer, that might have been a much more relevant argument.
What they meant was: "This aesthetic isn't exclusive to software rendering". I thought the rest of their comment made that pretty clear once you got past the first sentence.
I think the issue is that modern aliasing can be done without a GPU, so it's not that he loves software rendering, it's that he loves the style the constraints of the time imposed, and that style is not married to CPU-exclusive rendering.
Real players know you us the coarsest mipmap level the whole time, so every texture is something like 4 pixels. And 320x200 and directmouse. It's the smooth movement, high fps and direct control that provides the sense of "being there". Not the graphical fidelity.
Of course you can but I think author’s point is to actually test/evaluate maximum performance of true software rendering on modern machines, and this is fine and refreshing exercise, even with filtering.
It’s 100% software rendering on CPU just multithreaded. But no metal/direct3d just framebuffer and rest is yours routines… and I actually added bilinear filtering…
Still fun project to do and remind yourself about fundamental algorithms behind elementary 3D graphics
Yeah, when glquake and the Voodoo1 came out, I was actually initially disappointed because I'd seen demos of vquake on the verite and its texture mapping was closer to the original. But you couldn't complain about the framerate of the 3dfx.
His point is more about the texture filtering than about anti aliasing. Software rendered games never supported texture filtering (although they could have, at a significant cost), they always used simple nearest neighbor scaling. Of course you can turn filtering off on a GPU too, but hardly any game ever did that.
TAA has a pretty bad reputation among many gamers for being too blurry. TSR (temporal super resolution) is a newer implementation that's overall sharper, better at eliminating "jaggies", and performant, without visible ghosting or artifacting.
Indeed. Personally I am quite old-school, I like MSAA (despite the performance hit) and subpixel morphological AA (SMAA, used to great effect in Crysis). DLSS is interesting but I cannot unsee the artifacts.
TAA is a nightmare, and Unreal Engine depends way too much on it. TSR also suffer from ghosting and artifacts unfortunately.
But I have come to the realisation that gaming will be about massive compromises for the next decade.
"Software rendering went out of the window because the CPU tends to have other things to do besides just multiply 4x4 matrices, which was shifted to the shader cores of GPUs."
Hardware rendering took over because generating a 3D scene is embarrassingly parallel, and the industry quickly learned that you can have thousands of reasonably simple "cores" that can divide and conquer a scene in parallel. There was a no way a general purpose CPU could keep up.
Not so quickly. The shader cores were a breakthrough from early 2000s. First consumer GPUs were built as same as the 1980s GPUs but everything had been integrated in a single chip.
It is the sheer amount of compute and memory bandwidth that mogs a CPU but the parallel processing doesn't help much, at least in realistic 3D: an 8 core AVX-512 march CPU has an order of magnitude more SIMD lanes than something like RSX in PS3 yet it still wouldn't be able to match its performance in rendering textured z-buffered triangles. 3D graphics can really go wide only on wireframe/points, z-buffer forces sequencing between polys so the parallelism there is very limited.
How is it not software rendering? These games shipped without hardware renderers. Yes, they also don't have AA, but how does that make it not software rendering?
Here’s an analogy. Suppose someone said, “I love manual transmission cars” and then described in detail the physical knobs and dials that all the cars from the 1950s had.
It turns out what they like is physical knobs and dials. You can have those in automatic transmission cars. It so happens that most modern automatics also have shitty touchscreens.
(I know this analogy isn’t precise because there was a long period of automatics with physical controls, but bear with me.)
The point is that there’s nothing _inherent_ to software rendering that’s responsible for the thing he likes. The distinction is useful because, for example, he could go seek out modern games with the look he likes. Or make games. And if he thought the thing he likes comes from having a software renderer, he’d leave a lot of performance and power efficiency on the table for no good reason. He likes a certain rendering style that’s equally achievable with both GPU and CPU rendering. The choice of hardware should probably be driven by considerations like performance, debuggability, platform support, availability of libraries, etc.
In the first waves of multimedia PCs - the CPU was tasked with doing sound, networking, hard drive control, etc. - pretty much all of the cost savings came from having minimal hardware for the auxiliary components and doing it all in drivers.
A common "Trick" was to buy cards that had essentially their own processors to handle this stuff - SoundBlasters, 3Com nics, IDE drive controllers that had their own processor (hell, even up to their own OS) since that freed the CPU up for doing actual work - gaming. Even an external or other
CPUs were a bottle neck but most people didnt tax the single core machines doing most daily work (office work, browsing the web) so it was fine, but once you load up a game that needs sound, 3d, networking, disk access all at once it would start stealing clock cycles trying to do all of that in one place.
The sound card took sound computation off the CPU as well. Back in the day, every aspect of the game was fighting for CPU cycles.
Way back in the day there were some very impressive (given the technology) arcade ports to things like the Apple ][. That system's audio required running an assembly function that literally touched a memory address over and over again at a specific time rate; each touch flipped the electromagnet on the speaker. So games with theme music had to time slice hanging out in the audio routine versus doing anything else.
I grew up with a copy of Moon Patrol on Apple ][c and I didn't know for years that the theme song isn't supposed to sound like it's being played through a tea kettle.
MY NAME IS DOCTOR SBAITSO.
I AM HERE TO HELP YOU.
SAY WHATEVER IS IN YOUR MIND FREELY,
OUR CONVERSATION WILL BE KEPT IN STRICT CONFIDENCE.
MEMORY CONTENTS WILL BE WIPED OFF AFTER YOU LEAVE,
SO, TELL ME ABOUT YOUR PROBLEMS.
I think it's because adding a sound card offloaded sound processing from the CPU and it had more cycles to draw frames! Probably back when we were at like 25Mhz
CPUs from that era were single core and pretty slow. They had to do everything like game logic, graphics, sound, etc all at once, so it was often resource starved. Sound took some resources, sometimes significant depending on the sound and what else the cpu was doing, unless it was a really simple sound (think NES style sound). Moving that to a dedicated sound card meant the cpu didn't have to worry about sound anymore.
Sound, like a lot of things, could be seen as a peripheral and a lot of peripherals back then needed their own cpu to perform well. One interesting fact I recently learned is the commodore 64 was so resource starved, the external floppy drive you could buy had its own 6502, just like the C64 did as its main processor. It just had to off-load that to another cpu because its own cpu was too busy to reliably run a disk drive. There are other reasons for this like commodore's experience in drives previously was this kind of architecture so they went with what they knew, but its a bit interesting to know your floppy drive was essentially another C64 with its own commodore OS and ram and 6502.
Off-loads sample mixing to the sound card. Computers of that era were slow enough that doing 44100 additions per second was expensive (IIRC quake had 8Khz samples anyway).
I share the same opinion as the author. That said, it's also important to remember that the display devices of the time were different than they are now and the sharp pixelated textures we see now would look a bit different on a CRT from that period. The sharp, gritty look that he (and I) admire would have been just a little fuzzier back then.
A tiny bit fuzzier but not in a way that mattered back then. If you're running a software renderer it could well have been at 320x200 and on any monitor that comes out still looking pretty much like an LCD display, with slight blending on the edges technically but still large, large pixels not being blended. Even at 640x480 there was noticeable blockiness not being blended away. Monitors were designed to be sharper than the televisions the consoles were outputting to. Software rendering at anything high enough to be blended looking was a slideshow.
A lot of the fuzziness of TVs vs. PC monitors was down to the poor signaling (RF modulators, composite video). Some lucky/picky folks had TVs with component video (YPbPr) which produced images about as good as VGA monitors (RGB).
However, CRTs do not have fixed pixel geometries, and even when they produced relatively sharp images, they would seem fuzzier or softer in a side-by-side comparison with an LCD of the same size and resolution.
I recently got to try out Quake 2 on 9front, a Plan 9 fork, which ran surprisingly fast on my very, very modest Thinkpad T410i with a 2.4 GHz dual core i3 at 1440x900. Plan 9 has no GPU support so all rendering is software. Even had a little lan party with other devs. I really enjoyed the software rendering, it bought back early memories of playing Q2 before we bought our Voodoo2. I even used my ploopy trackball to play. Fun times.
Presently, Plan 9 in general lacks 3D graphics but has an in-kernel 2D rendering engine referred to as devdraw. Quake 2 software rendering is done in-engine by rendering full frames to a bitmap displayed by devdraw. A fun experiment was to rcpu into my industrial DIN rail PC, a 1.2 GHz 4 core Atom, from the Thinkpad and play Quake 2. When I run Quake 2, it runs on the CPU server but graphics are sent to my laptop. However, since Q2 is rendered in-engine on the remote iPC, full frames are copied over gigE to my laptop. Q2 full screen was stuttering badly but at about 1/4 screen size it was surprisingly playable.
An other example is a port of cave story done by a 9dront dev where he integrated devdraw so the game renders by loading its assets into devdraw and issuing rendering commands. It is likely the first Plan 9 native game. It plays perfectly over an rcpu session at full screen as the rendering is done by the client side devdraw.
Another 9front dev is doing a lot of graphics work and implemented affine warping in devdraw which is useful for rapidly transforming bitmaps, e.g. scaling the output of the gameboy emulator and Doom. He and others are interested in implementing a concurrent 3D rendering software devdraw engine as we have many-core machines now. When GPU's first hit the streets, we were on single core machines. SMP machines were not affordable by mere mortals when the 3Dfx Voodoo hit the market. So the idea is, why struggle with the gargantuan task of implementing a "modern" GPU stack when you have all these CPU cores now? Why not take a step back, think about what we have learned, and extract all the performance we can from modern many-core CPUs with all sorts of vector extensions. In a Plan 9 context, you could run the game on a many core machine to handle game logic and play remotely with a bigger many-core spraying pixels at a display. Distributed gaming. Might even be able to do multiplayer with a single engine instance with multiple rendering clients attached. Fun system to play with.
I'm going to guess if you did it on the video card and simply disabled those enhancements it would be considerably more energy efficient than doing it on the CPU as well which (a) means your laptop battery lasts longer on a charge, and (b) also opens up the possibility of not needing a particularly powerful CPU in order to juice the resolution, because the video hardware is doing the work for you.
From a programming perspective I do completely get the desire to have the CPU do all the work though - if you want absolutely everything under your control it's easier, and especially if your game is single-threaded.
I've mentioned this elsewhere, but nowadays, anything you see out of an HDMI/DP/eDP cable comes out of a GPU. Modern OSs make it impossible to do 'software rendering' any more; it's just that much faster and that much more efficient, even if it is harder to program directly. Even IPMI BMCs have a tiny GPU doing stuff.
Concur. Feels like a conflation; CPU vs GPU rendering doesn't change the appearance directly. The article performs further conflations later re the OS comparison and Steam re Ion Fury etc.
It just feels wrong historically. When HL came out, people were very enthusiastic about texture filtering and the game was clearly designed with hardware rendering in mind.
makes me wonder how would gameplay fare when a gpu renders the game with very limited options. Sometimes higher FPS would play weirdly with the physics engine and some moves you could do when capped at 24fps were not possible at 60fps.
I like when games use nearest, or dedicated pixel art shaders. Bilinear just looks low-effort to me, especially when it's used for whole-screen scaling! Apple's Lanczos also looks a bit disgusting to me, I can't tolerate the display scaling on iPad because of this.
Shameless plug of my upcoming game [1] which uses software rendering. Also did a Show HN and write-up [2] last year for a previous game [3] using the same engine.
Software rendering was useful for me for a long time but as a long-time gamer (from the original DOOM to Cyberpunk 2077 and beyond) I can firmly say that real-time raytraced games at 4K/60FPS with dynamic lighting, reflections, massive geometry detail, etc, all greatly enhance the experience. That said, the old DOOM aesthetic pre-Voodoo was definitely nice. The voodoo smoothing had a nice cheap feel to it, too.
The difference in performance is just so big, unless you're targeting something without a GPU, there is no world in which you would want to leave it unutilized IMO, even if you're just rendering an UI. I can do things on my slow phone in WebGL that would stutter on my desktop if I drew the pixels with the CPU.
That screenshot is 800x600 - he probably wouldn't love software rendering at 320x240 which is what we actually had to run to get decent fps back in the day (late 90s). That was the the other big unlock of 3dfx voodoo, it could do 640x480 at 30 fps.
Unreal (and Unreal Tournament), Thief, Quake II (a slight improvement over Quake), Half-Life (a great improvement over Quake), Shadow Warrior,
Any modern port of Doom supporting software rendering, Heretic, Hexen, Descent, System Shock, Homeworld.
Quake II is a completely different game from Quake, isn't it? The levels, artwork and gameplay feel quite different. I personally prefer the look and feel of the original Quake, particularly when using the Arcane Dimensions mod.
Software renderer of Quake II has no colored lighting. It's OpenGL-only feature. Half-Life and Unreal do this better, they support colored lighting in their software mode.
Firstly, if you're going to write about something you like, you should write it yourself. LLMs just make your writing worse. There are no exceptions to this rule.
Secondly, I love software rendering too. The nicest rendering I ever made was painters-algorithm sorted and shaded by the z-component. It just looked so simple and lovely.
The article says that "even a 3.3GHz quad-core Xeon “isn’t quite enough to run Shadow Warrior at full 1600 by 1200”." But we are on DOS, so I guess three cores are just not doing anything there?
That quote about Shadow Warrior doesn't pass the smell test. You're right there must be bottlenecks in the way.
The Build engine's rendering was stunningly simple (and dare I say: elegant). You could run hundreds of instances of Shadow Warrior on a single EPYC (since they mentioned Xeon) at that resolution and framerate if you rewrote the engine with modern mechanical sympathy in mind. On a modern desktop CPU it'd probably be over a hundred instances.
People, including many programmers, just don't grasp how much power we have under the hood nowadays...
Edit: my old iPhone SE, fully utilized, can produce the same GFLOPS as the Cray T3E (the one with thousands of DEC Alphas inside). This is our reality.
Quake DOS is from a year earlier to Shadow Warrior and it would get around 60fps at 320x200 on a Pentium II 266. The Xeon from that video is from 2008, and from geekbench 2 results it's ~30 times faster than the pentium. 1600x1200 is 30 times the pixels of 320x200.
Additionally Shadow Warrior used some newer rendering techniques, so it's possible they don't scale well to higher resolutions.
Because the pipelines lacked fast, dedicated linear algebra engines, you saw a lot of clever hacks to get around having to do full linear algebra as well.
The original Marathon allowed you to look up and down, but it wasn't actually tilting the camera frame; it was applying a distortion on the field of view and then basically vertical scrolling the render target. Essentially, you can think of it like you were playing the game in vertical phone mode all the time but you were looking at the middle third of that possible output domain, and looking up and down pretty much just scrolled what you were looking at and applied a trapezoid transform.
This is why you couldn't look straight up or straight down, the trapezoid transform would become painfully obvious quickly and the actual algorithm did not really tilt your field of view.
But it was good enough that they could slap it on the box as a novel feature for Wolfenstein style first person shooters.
None of the benefits listed are exclusive to software rendering. There is literally nothing software renderer can do that GPU one can't. But I get that from historical perspective this not always was the case (esp. before programmable GPU pipelines).
I think software render is much easier to port than GPU? Since you only need to implement blitting the image buffer to the screen. Also having direct easy access to the image buffers can help you make effects easier? Please educate me I'm not that well versed in current GPU programming.
You know what I found this past year was that I could NOT find any way, to turn off anti-aliasing, for text inside a webview. I made a whole entire custom terminal app just for myself in Rust, Tauri, xterm.js and spent a ton of time trying to un-blur the text but failed. I redid the entire thing (well, Codex/Claude mostly) using a rust graphics library (egui) and now the text is finally sharp! and its fast. I am growing more and more anti webview with these AI coding tools.. they can almost one-shot convert a slow webview app into something that uses 1/10th the ram and 10x as fast. The text looks soooo much better, all fonts look better. In xterm.js, text looks super fat all the time (to me).
You are asking for a look that’s very niche. Not many people hate anti-aliasing so much. GNOME still has a simple UI to turn off anti-aliasing but not many apps respect that. The modern text rendering pipeline is just way too complicated from font lookup, ligatures, shaping, etc. To achieve this look in web views you’ll most certainly need to do it in <canvas>. And of course, you can still choose to draw all the text using software rendering using JavaScript or use WebGL2 and ship it to the GPU: conveniently the constructor allows you to turn off antialiasing `canvas.getContext("webgl2", {antialias: false})`.
I predict a shift towards antialiasing being less desirable as DPI->inf. In my experience, disabling antialiasing dramatically improves sharpness and readability of small font sizes on modern 4K+ monitors, along with reducing eye strain and surprising bystanders.
You could also render the text inside a canvas in a web view, then you have a bit more control over the sampling. If you wanted to stick to a web view for some reason that is. Alternatively you could generate custom bitmap fonts on the fly based on the screen resolution.
Everyone is already pointing out this isn't quite software rendering but rather the rendering technique which used to be the only option. I'll add that even without a GPU, CPUs will have integrated graphics. There are CPUs that don't have this but in those cases you need a GPU. The point is that modern systems no longer use CPU to output to the screen, either there is an integrated GPU or a GPU card on the system. So in a way the term "software rendering" is only applicable to special cases of embedded systems that actually use CPUs for graphics.
I'm not totally sure what you're trying to say. Even back in the days of "software rendering" - or on those embedded systems that you're describing - you still had a piece of graphics hardware that converted the frame buffer into whatever got spit out to the monitor, so I don't think this is meaningful, really.
What's meant by software rendering is really software rasterization - the process of taking the triangles, textures, etc. of the scene and turning those into the pixels that eventually make their way to the screen. You can still do that in software on the CPU today without touching the GPU, even the integrated one. At that point you hand it off to the hardware to make its way to the screen, sure, but it's only an implementation detail that makes that different from handing 0xA0000000 over to the VGA card. The interesting part of the process, and the results, are functionally the same.
The difference is if it's hardware accelerated or not, or at least that's my understanding. Software rendering means there is no hardware acceleration. I think the term is outdated because typically it means you don't use the GPU, and this was true like a decade ago and earlier, but I think today CPUs have integrated graphics, so it's like they have tiny GPUs to help render to the screen because it's more efficient. So even if someone is not using a physical GPU, chances are the CPU still uses hardware acceleration, and that's why it works so well today.
I have an Intel i9 with no integrated graphics, if I don't use a GPU, the screen would barely render in very low resolution, although haven't really test it that. I can disable hardware acceleration in the browser and it spikes several CPU cores and is terribly inefficient.
Besides differences in texture mapping, the way GPUs render triangles is quite different to techniques commonly used in the old days. No one was computing barycentric coordinates and checking if every pixel was inside a triangle - it’s too slow to do that on a single thread. At low resolutions you get very different visual results because a GPU will not render triangles that do not cover the center of a pixel without anti-aliasing.
Precise and consistent fill conventions don't need barycentric coordinates, it simply needs some care in rasterization. Chris Hecker's 1985 texture mapping series in Game Developer covered how to do this properly in a traditional software scanline rasterizer. The necessary prestepping isn't expensive.
A few years ago I seriously contemplated making a game using software rendering, in part because the only target was SDL. I actually got a 3D engine running 2K@60Hz with HL2-level scenes, with the CPU basically idle, so it's not a terrible idea.
(Then LLMs started taking off and I decided I needed to reskill out of the industry, just in case)
I know this is not entirely what this article is about, but I love software rendering for desktop apps. It seems to me that the performance impact with proper paint invalidation is negligible, but doesn't suffer from the same driver issues as hardware accelerated rendering seems to have. Bonus that it doesnt use any GPU resources in the age of AI
Its so interesting to me that back then we would have died for the graphics we have today, and now this retro look is being appreciated. I mean, it definitely has an aesthetic but its generally unappealing. I guess nothing is immune to nostalgia and pining for being at the age when we had less responsibilities and life seemed easier.
I remember when I finally saw my favourite 3D games (Quake 2 and Pod) on a Voodoo2 and I immediately bristled: I hated the blurry way the textures looked with bilinear filtering, and was iffy on their love of yellow lighting.
I've softened on the issue of non-white lights, but I 100% am still full of nostalgia about unflitered low-res textures.
Michael Abrash's Graphics Programming Black Book is still one of my all time favourite. What they did back then was almost black magic. I learned a good part of maths, cs and physics trying to mod id1 with this book during my teenaghood.
Unfortunately I didn’t do anything as impressive as modding a game; I read the book because the writing style itself was engaging and gripping like a novel.
I love Software Rendering too! I'd add Unreal Tournament to the list of "Games worth trying", though not sure what the multiplayer scene is like nowadays.
It's a faithful port of Quake's original software renderer. Everything happens on the CPU, which made it easier to match the original exactly. In theory the same could be done on a GPU, but I think it would be harder and messier.
The trade-off with software renderer is that it's more code. With GLQuake much of the actual rendering work is handed off to OpenGL itself, i.e. the driver and the GPU. In the software renderer, the engine does all of that in its own code.
I am still a big fan of CPU render for VFX (not games). It is stable, capable of very large scenes. GPU is fast but you will never render something really big. And CPU look is much much better.
> you will never render something really big. And CPU look is much much better.
Why do you believe these things? In VFX and film, the GPU shaders and rendering is identical to CPU, they use the exact same programmable shaders on either side, so there is no difference in look or capability. Today’s GPUs have out of core streaming and caching and access to host memory. Pixar showed off their pixel-matching between GPU and CPU at Siggraph this year, and mentioned that today’s consumer GPUs are big enough to render IIRC ~98% of their scenes without much ‘out-of-core’ tech. Lots of film and VFX studios are using GPUs in production today to render pretty big shots. I think your story is a bit out of date; GPUs being size limited was somewhat true in the past, but is quickly going away. The CPU vs GPU look question has never been true for VFX or film, and was only true in games if you chose different rendering algorithms.
I don’t know much about this so I’m curious. Is the reason why GPUs aren’t preferable for large scenes due to their limited VRAM or a different aspect of them?
“Software rendering” usually means “doing rasterization on the CPU”, as opposed to “hardware rendering” that is done by the rasterization primitives of the GPU.
Nanite is a bit weird because it doesn't use the hardware rasterization of the GPU, but it's still doing rasterization on the GPU, so it doesn't really fit this dichotomy.
Eh, Nanite rasterisation is still happening on the GPU, it's "just" implemented in shaders rather than using the fixed-function pipeline. "Software rendering" is becoming less useful as a descriptor as graphics hardware becomes more general.
No software rendering requires DOS, you could use it with Windows back in the day (how I originally played Half Life) and engines that still support it will run on modern OSes too.
Wrote a little software rasterizer for a roguelike years back and the best part was just being able to step through the whole pipeline in a debugger. No driver weirdness, no shader compile quirks, the pixel is wrong because your math is wrong.
Yeah, that is the hardest part about 3D graphics programming, at least it was the last time I had my elbows deep in it.
You're not doing traditional application programming once you get into 3D graphics. You are driving a microcomputer at arm's length. Every aspect of that challenge comes into play, from the fact that it's a black box to how you can have it working perfectly in one configuration of hardware, and then find it doesn't work on another configuration.
My favorite reasons for this include "there is a legitimate bug in the closed-source shader compiler" and "this graphics card advertises a capability but in reality it implements it in software so if you turned that flag on your render speed suddenly went to seconds per frame."
The CUDA era helped some with this problem because there was suddenly massive pressure on making the GPU into less of a bundle of pipelines and specialty hardware accelerators strapped together and more into standardized massively parallel fabric, because card manufacturers suddenly found themselves not wanting to be left out in the cold if they invested their time in building a very very fancy specialty hardware circuit for doing texture manipulation or something... And that proved to be useless for mining Bitcoin, or whatever they suspected might replace Bitcoin in the future. I think there are far less gotchas now regarding weird architecture than there were in the 2010s.
> Ion Fury, a Build engine game from 2019, still ships with a software renderer.
Amazing game BTW, best shooter I've played in many years. I never really got into build engine games back then, so it's not just my rose-tinted glasses, that game is a masterpiece.
Ion Fury uses a modified version of eDuke32 which can do software only rendering, and quite well, but defaults to GPU acceleration because Ion Fury uses the real time lighting.
That said, the Build Engine had software voxels in 1997. Which was pretty cool.
I don't think it really applies when we're talking about PC gaming. Consoles were blurry as hell on a huge interlaced low-res TV, but late-'90s PC games on a decent monitor had nice and crisp pixels on a CRT that weighed as much as a large dog. Especially when flat-glass trinitron CRTs and the like came out (yes spellcheck, that's a word), I don't think the end-user appearance on the screen was all that different from what we have now, other than obvious stuff like aspect ratio and incremental improvements to resolution and framerate. Maybe deeper blacks and lower latency on CRT.
The ability to shift resolutions natively was neat, though, I missed that in the pre-4K days.
Even the oldest and cheapest CRT monitor my family had was pretty pixel-accurate unless you were right at the edges. I was doing pixel art on it as a child and had no issues at all.
Software rendering often provided better visual effects than the GPU paths could provide at the time. A general purpose CPU can technically do any effect since the software is the pixel shader.
Programmable shader pipelines weren't a thing until Geforce 3 in 2001.
And alternative rendering methods like Commanche's voxel weren't doable on the GPU for a long time.
Commanche was a height-map raycaster. There were no voxels to be found.
1 reply →
....and it always sucked, sucks currently and will suck in the future. For several reasons.
The market clearly decided the tech. And yes, for I felt Comanche'94 was just uggly and "bricky"
1 reply →
Ah,Sorry,in 2001 it was actually the first, so Geforce 1 / ONE.
It hat -fasten your seatbelts- one(!) dedicated pixelshader and one dedicated vertexshader :-) High times back then - it was like entering next dimension.
(Two chips, guys, two!)
I really admire Woof[1] sourceport of DOOM and how it can achieve high fps at modern resolutions using software rendering (Sure, there are still GPU apis at work behind the scenes managing swapchain and all but rendering logic is still software). Also it's worth checking out for anybody who wants to see a good SDL3 codebase.
[1] https://github.com/fabiangreffrath/woof/
[2] https://github.com/fabiangreffrath/crispy-doom/ (simpler doom port from which woof inherited its rendering code)
This isn't software rendering, it's called turning off spatial anti-aliasing. You can still do that in the modernest of modern games. Software rendering went out of the window because the CPU tends to have other things to do whilst playing the game besides only multiplying 4x4 matrices, which was shifted to the shader cores of GPUs. The look-and-feel that the author is discussing including shadow and texture LUTs can also be done on GPUs by passing the tables in to shaders as constant read-only storage buffers; that is not specific to software rendering. It bears mentioning that many modern software renderers (LLVMpipe/Lavapipe, OpenSWR, WARP) are basically full D3D/OpenGL/Vulkan devices in their own right, including shader compilers.
Also, modern spatial anti-aliasing works by multisampling within a pixel (or even neighbouring pixels) and taking the average, rather than filtering across singly-sampled pixels, which massively reduces the quality. Not to mention temporal and machine learning AA techniques including DLSS, XeSS, FSR, and all the TAA implementations in many games.
His definition of software rendering is
I think that’s the standard definition. If you mean that this style can be achieved with graphics hardware then that’s a different argument and why your first sentence is deemed contentious
> If you mean that this style can be achieved with graphics hardware
I really ought to have been more specific with my first sentence to ward off any hair-splitting.
The author claimed to love software rendering, but the examples given to highlight the supposed positives of software rendering can all be achieved on GPUs. If the author had instead highlighted the ability to easily debug and inspect the inner workings of the rasterisation pipeline with a software renderer, that might have been a much more relevant argument.
23 replies →
What they meant was: "This aesthetic isn't exclusive to software rendering". I thought the rest of their comment made that pretty clear once you got past the first sentence.
I think the issue is that modern aliasing can be done without a GPU, so it's not that he loves software rendering, it's that he loves the style the constraints of the time imposed, and that style is not married to CPU-exclusive rendering.
Yes - but most of the rest of the article describes something different! (Which is what the post you're replying to explains)
yup, it should be renamed to "I Love GL_NEAREST_MIPMAP_NEAREST"
Real players know you us the coarsest mipmap level the whole time, so every texture is something like 4 pixels. And 320x200 and directmouse. It's the smooth movement, high fps and direct control that provides the sense of "being there". Not the graphical fidelity.
6 replies →
Of course you can but I think author’s point is to actually test/evaluate maximum performance of true software rendering on modern machines, and this is fine and refreshing exercise, even with filtering.
This actually what I have also returned to in my latest demoscene demo: https://www.pouet.net/prod.php?which=106969
It’s 100% software rendering on CPU just multithreaded. But no metal/direct3d just framebuffer and rest is yours routines… and I actually added bilinear filtering…
Still fun project to do and remind yourself about fundamental algorithms behind elementary 3D graphics
You have to admit, it makes for a less catchy title
T-shirt worthy
Yeah, when glquake and the Voodoo1 came out, I was actually initially disappointed because I'd seen demos of vquake on the verite and its texture mapping was closer to the original. But you couldn't complain about the framerate of the 3dfx.
His point is more about the texture filtering than about anti aliasing. Software rendered games never supported texture filtering (although they could have, at a significant cost), they always used simple nearest neighbor scaling. Of course you can turn filtering off on a GPU too, but hardly any game ever did that.
> Software rendered games never supported texture filtering
Unreal did. Or maybe Unreal 2, I don't remember which.
1 reply →
> it's called turning off spatial anti-aliasing.
It's called "nearest neighbour texture sampling", as opposed to bilinear/trilinear/anisotropic
Software rendering went out of style because z-buffer based rasterization is embarrassingly parallel and benefits from a hardware implementation.
TAA has a pretty bad reputation among many gamers for being too blurry. TSR (temporal super resolution) is a newer implementation that's overall sharper, better at eliminating "jaggies", and performant, without visible ghosting or artifacting.
Indeed. Personally I am quite old-school, I like MSAA (despite the performance hit) and subpixel morphological AA (SMAA, used to great effect in Crysis). DLSS is interesting but I cannot unsee the artifacts.
TAA is a nightmare, and Unreal Engine depends way too much on it. TSR also suffer from ghosting and artifacts unfortunately. But I have come to the realisation that gaming will be about massive compromises for the next decade.
TAA introduce aliasing on fast moving element which is far more annoying than blurring
1 reply →
"Software rendering went out of the window because the CPU tends to have other things to do besides just multiply 4x4 matrices, which was shifted to the shader cores of GPUs."
Hardware rendering took over because generating a 3D scene is embarrassingly parallel, and the industry quickly learned that you can have thousands of reasonably simple "cores" that can divide and conquer a scene in parallel. There was a no way a general purpose CPU could keep up.
Not so quickly. The shader cores were a breakthrough from early 2000s. First consumer GPUs were built as same as the 1980s GPUs but everything had been integrated in a single chip.
It is the sheer amount of compute and memory bandwidth that mogs a CPU but the parallel processing doesn't help much, at least in realistic 3D: an 8 core AVX-512 march CPU has an order of magnitude more SIMD lanes than something like RSX in PS3 yet it still wouldn't be able to match its performance in rendering textured z-buffered triangles. 3D graphics can really go wide only on wireframe/points, z-buffer forces sequencing between polys so the parallelism there is very limited.
5 replies →
spatial anti-aliasing
aka (just) anti-aliasing, we are talking original quake 1 era, after all.
How is it not software rendering? These games shipped without hardware renderers. Yes, they also don't have AA, but how does that make it not software rendering?
Here’s an analogy. Suppose someone said, “I love manual transmission cars” and then described in detail the physical knobs and dials that all the cars from the 1950s had.
It turns out what they like is physical knobs and dials. You can have those in automatic transmission cars. It so happens that most modern automatics also have shitty touchscreens.
(I know this analogy isn’t precise because there was a long period of automatics with physical controls, but bear with me.)
The point is that there’s nothing _inherent_ to software rendering that’s responsible for the thing he likes. The distinction is useful because, for example, he could go seek out modern games with the look he likes. Or make games. And if he thought the thing he likes comes from having a software renderer, he’d leave a lot of performance and power efficiency on the table for no good reason. He likes a certain rendering style that’s equally achievable with both GPU and CPU rendering. The choice of hardware should probably be driven by considerations like performance, debuggability, platform support, availability of libraries, etc.
3 replies →
The point is that the thing that OP likes has nothing to do with whether something is rendered in software or hardware.
16 replies →
They mean that what the OP prefers about it is not the fact that it’s done in software. “This” is “the thing the OP seems to prefer”.
1 reply →
[flagged]
Ah the software rendering era. Where I gained 10fps by adding a sound card.
I'm interested in hearing more
In the first waves of multimedia PCs - the CPU was tasked with doing sound, networking, hard drive control, etc. - pretty much all of the cost savings came from having minimal hardware for the auxiliary components and doing it all in drivers.
A common "Trick" was to buy cards that had essentially their own processors to handle this stuff - SoundBlasters, 3Com nics, IDE drive controllers that had their own processor (hell, even up to their own OS) since that freed the CPU up for doing actual work - gaming. Even an external or other
CPUs were a bottle neck but most people didnt tax the single core machines doing most daily work (office work, browsing the web) so it was fine, but once you load up a game that needs sound, 3d, networking, disk access all at once it would start stealing clock cycles trying to do all of that in one place.
13 replies →
The sound card took sound computation off the CPU as well. Back in the day, every aspect of the game was fighting for CPU cycles.
Way back in the day there were some very impressive (given the technology) arcade ports to things like the Apple ][. That system's audio required running an assembly function that literally touched a memory address over and over again at a specific time rate; each touch flipped the electromagnet on the speaker. So games with theme music had to time slice hanging out in the audio routine versus doing anything else.
I grew up with a copy of Moon Patrol on Apple ][c and I didn't know for years that the theme song isn't supposed to sound like it's being played through a tea kettle.
2 replies →
I think it's because adding a sound card offloaded sound processing from the CPU and it had more cycles to draw frames! Probably back when we were at like 25Mhz
CPUs from that era were single core and pretty slow. They had to do everything like game logic, graphics, sound, etc all at once, so it was often resource starved. Sound took some resources, sometimes significant depending on the sound and what else the cpu was doing, unless it was a really simple sound (think NES style sound). Moving that to a dedicated sound card meant the cpu didn't have to worry about sound anymore.
Sound, like a lot of things, could be seen as a peripheral and a lot of peripherals back then needed their own cpu to perform well. One interesting fact I recently learned is the commodore 64 was so resource starved, the external floppy drive you could buy had its own 6502, just like the C64 did as its main processor. It just had to off-load that to another cpu because its own cpu was too busy to reliably run a disk drive. There are other reasons for this like commodore's experience in drives previously was this kind of architecture so they went with what they knew, but its a bit interesting to know your floppy drive was essentially another C64 with its own commodore OS and ram and 6502.
So was Waterluvian, I assume, which is probably why they added the card!
Off-loads sample mixing to the sound card. Computers of that era were slow enough that doing 44100 additions per second was expensive (IIRC quake had 8Khz samples anyway).
7 replies →
[dead]
“I just need to find another 12K of conventional memory to launch this game…”
I share the same opinion as the author. That said, it's also important to remember that the display devices of the time were different than they are now and the sharp pixelated textures we see now would look a bit different on a CRT from that period. The sharp, gritty look that he (and I) admire would have been just a little fuzzier back then.
A tiny bit fuzzier but not in a way that mattered back then. If you're running a software renderer it could well have been at 320x200 and on any monitor that comes out still looking pretty much like an LCD display, with slight blending on the edges technically but still large, large pixels not being blended. Even at 640x480 there was noticeable blockiness not being blended away. Monitors were designed to be sharper than the televisions the consoles were outputting to. Software rendering at anything high enough to be blended looking was a slideshow.
Unless you were playing on a TV CRT, I don't think so. PC monitors of the time were pretty sharp already.
A lot of the fuzziness of TVs vs. PC monitors was down to the poor signaling (RF modulators, composite video). Some lucky/picky folks had TVs with component video (YPbPr) which produced images about as good as VGA monitors (RGB).
However, CRTs do not have fixed pixel geometries, and even when they produced relatively sharp images, they would seem fuzzier or softer in a side-by-side comparison with an LCD of the same size and resolution.
I recently got to try out Quake 2 on 9front, a Plan 9 fork, which ran surprisingly fast on my very, very modest Thinkpad T410i with a 2.4 GHz dual core i3 at 1440x900. Plan 9 has no GPU support so all rendering is software. Even had a little lan party with other devs. I really enjoyed the software rendering, it bought back early memories of playing Q2 before we bought our Voodoo2. I even used my ploopy trackball to play. Fun times.
Presently, Plan 9 in general lacks 3D graphics but has an in-kernel 2D rendering engine referred to as devdraw. Quake 2 software rendering is done in-engine by rendering full frames to a bitmap displayed by devdraw. A fun experiment was to rcpu into my industrial DIN rail PC, a 1.2 GHz 4 core Atom, from the Thinkpad and play Quake 2. When I run Quake 2, it runs on the CPU server but graphics are sent to my laptop. However, since Q2 is rendered in-engine on the remote iPC, full frames are copied over gigE to my laptop. Q2 full screen was stuttering badly but at about 1/4 screen size it was surprisingly playable.
An other example is a port of cave story done by a 9dront dev where he integrated devdraw so the game renders by loading its assets into devdraw and issuing rendering commands. It is likely the first Plan 9 native game. It plays perfectly over an rcpu session at full screen as the rendering is done by the client side devdraw.
Another 9front dev is doing a lot of graphics work and implemented affine warping in devdraw which is useful for rapidly transforming bitmaps, e.g. scaling the output of the gameboy emulator and Doom. He and others are interested in implementing a concurrent 3D rendering software devdraw engine as we have many-core machines now. When GPU's first hit the streets, we were on single core machines. SMP machines were not affordable by mere mortals when the 3Dfx Voodoo hit the market. So the idea is, why struggle with the gargantuan task of implementing a "modern" GPU stack when you have all these CPU cores now? Why not take a step back, think about what we have learned, and extract all the performance we can from modern many-core CPUs with all sorts of vector extensions. In a Plan 9 context, you could run the game on a many core machine to handle game logic and play remotely with a bigger many-core spraying pixels at a display. Distributed gaming. Might even be able to do multiplayer with a single engine instance with multiple rendering clients attached. Fun system to play with.
This should really be titled "I love pixelated textures".
> "3D cards smoothed textures with bilinear filtering"
You can just not do that.
I'm going to guess if you did it on the video card and simply disabled those enhancements it would be considerably more energy efficient than doing it on the CPU as well which (a) means your laptop battery lasts longer on a charge, and (b) also opens up the possibility of not needing a particularly powerful CPU in order to juice the resolution, because the video hardware is doing the work for you.
From a programming perspective I do completely get the desire to have the CPU do all the work though - if you want absolutely everything under your control it's easier, and especially if your game is single-threaded.
I've mentioned this elsewhere, but nowadays, anything you see out of an HDMI/DP/eDP cable comes out of a GPU. Modern OSs make it impossible to do 'software rendering' any more; it's just that much faster and that much more efficient, even if it is harder to program directly. Even IPMI BMCs have a tiny GPU doing stuff.
10 replies →
Concur. Feels like a conflation; CPU vs GPU rendering doesn't change the appearance directly. The article performs further conflations later re the OS comparison and Steam re Ion Fury etc.
It's just like how pixelated 2D graphics is called "8-bit" now.
Valve added this as an option to Half-Life in the 25th anniversary update, and I thank them for it - it looks much cooler.
It just feels wrong historically. When HL came out, people were very enthusiastic about texture filtering and the game was clearly designed with hardware rendering in mind.
3 replies →
That said, Black Mesa is a marvelous piece of work. The Xen levels feel like they finally finished them.
makes me wonder how would gameplay fare when a gpu renders the game with very limited options. Sometimes higher FPS would play weirdly with the physics engine and some moves you could do when capped at 24fps were not possible at 60fps.
I like when games use nearest, or dedicated pixel art shaders. Bilinear just looks low-effort to me, especially when it's used for whole-screen scaling! Apple's Lanczos also looks a bit disgusting to me, I can't tolerate the display scaling on iPad because of this.
If you want to have the true PSX gaming experience you can also round all vertex coordinates to the next pixel and force noperspective interpolation.
[dead]
I spent decades writing software rendering engines for my games. benefit is lots of control and flexibility
Shameless plug of my upcoming game [1] which uses software rendering. Also did a Show HN and write-up [2] last year for a previous game [3] using the same engine.
[1] https://store.steampowered.com/app/5277420/Omega_Transmissio... [2] https://news.ycombinator.com/item?id=45270981 [3] https://totenarctanz.itch.io/a-scavenging-trip
Software rendering was useful for me for a long time but as a long-time gamer (from the original DOOM to Cyberpunk 2077 and beyond) I can firmly say that real-time raytraced games at 4K/60FPS with dynamic lighting, reflections, massive geometry detail, etc, all greatly enhance the experience. That said, the old DOOM aesthetic pre-Voodoo was definitely nice. The voodoo smoothing had a nice cheap feel to it, too.
The difference in performance is just so big, unless you're targeting something without a GPU, there is no world in which you would want to leave it unutilized IMO, even if you're just rendering an UI. I can do things on my slow phone in WebGL that would stutter on my desktop if I drew the pixels with the CPU.
I too. So that I have written many software renderers in many years. A video with my recent project having a software renderer: https://www.youtube.com/watch?v=NepOPAPDvwA
That screenshot is 800x600 - he probably wouldn't love software rendering at 320x240 which is what we actually had to run to get decent fps back in the day (late 90s). That was the the other big unlock of 3dfx voodoo, it could do 640x480 at 30 fps.
[dead]
The original Half-Life also supports software rendering, and it has a unique water texture effect that the OpenGL renderer doesn't have.
> Games worth trying
I can add more:
Unreal (and Unreal Tournament), Thief, Quake II (a slight improvement over Quake), Half-Life (a great improvement over Quake), Shadow Warrior, Any modern port of Doom supporting software rendering, Heretic, Hexen, Descent, System Shock, Homeworld.
Quake II is a completely different game from Quake, isn't it? The levels, artwork and gameplay feel quite different. I personally prefer the look and feel of the original Quake, particularly when using the Arcane Dimensions mod.
> Quake II (a slight improvement over Quake)
That colored lighting, though.
Software renderer of Quake II has no colored lighting. It's OpenGL-only feature. Half-Life and Unreal do this better, they support colored lighting in their software mode.
Firstly, if you're going to write about something you like, you should write it yourself. LLMs just make your writing worse. There are no exceptions to this rule.
Secondly, I love software rendering too. The nicest rendering I ever made was painters-algorithm sorted and shaded by the z-component. It just looked so simple and lovely.
Felt like a human wrote it to me
I hate AI written slop as well, but this blog post doesn't read like one?
Agreed. This reads like a human to me.
The article says that "even a 3.3GHz quad-core Xeon “isn’t quite enough to run Shadow Warrior at full 1600 by 1200”." But we are on DOS, so I guess three cores are just not doing anything there?
That quote about Shadow Warrior doesn't pass the smell test. You're right there must be bottlenecks in the way.
The Build engine's rendering was stunningly simple (and dare I say: elegant). You could run hundreds of instances of Shadow Warrior on a single EPYC (since they mentioned Xeon) at that resolution and framerate if you rewrote the engine with modern mechanical sympathy in mind. On a modern desktop CPU it'd probably be over a hundred instances.
People, including many programmers, just don't grasp how much power we have under the hood nowadays...
Edit: my old iPhone SE, fully utilized, can produce the same GFLOPS as the Cray T3E (the one with thousands of DEC Alphas inside). This is our reality.
Quake DOS is from a year earlier to Shadow Warrior and it would get around 60fps at 320x200 on a Pentium II 266. The Xeon from that video is from 2008, and from geekbench 2 results it's ~30 times faster than the pentium. 1600x1200 is 30 times the pixels of 320x200.
Additionally Shadow Warrior used some newer rendering techniques, so it's possible they don't scale well to higher resolutions.
Sources: * https://framebuffer.io/project/quake * https://browser.geekbench.com/geekbench2/327940 * https://browser.geekbench.com/geekbench2/529270
1 reply →
Didnt someone have software rendering for Crysis on a third-generation Threadripper?
Because the pipelines lacked fast, dedicated linear algebra engines, you saw a lot of clever hacks to get around having to do full linear algebra as well.
The original Marathon allowed you to look up and down, but it wasn't actually tilting the camera frame; it was applying a distortion on the field of view and then basically vertical scrolling the render target. Essentially, you can think of it like you were playing the game in vertical phone mode all the time but you were looking at the middle third of that possible output domain, and looking up and down pretty much just scrolled what you were looking at and applied a trapezoid transform.
This is why you couldn't look straight up or straight down, the trapezoid transform would become painfully obvious quickly and the actual algorithm did not really tilt your field of view.
But it was good enough that they could slap it on the box as a novel feature for Wolfenstein style first person shooters.
None of the benefits listed are exclusive to software rendering. There is literally nothing software renderer can do that GPU one can't. But I get that from historical perspective this not always was the case (esp. before programmable GPU pipelines).
I think software render is much easier to port than GPU? Since you only need to implement blitting the image buffer to the screen. Also having direct easy access to the image buffers can help you make effects easier? Please educate me I'm not that well versed in current GPU programming.
True, although graphics portability has improved quite a bit thanks to Vulkan, WebGPU, Wine, and others.
The thing is, back then CPU were super slow and more complex software renderers were actually not useable/available
You know what I found this past year was that I could NOT find any way, to turn off anti-aliasing, for text inside a webview. I made a whole entire custom terminal app just for myself in Rust, Tauri, xterm.js and spent a ton of time trying to un-blur the text but failed. I redid the entire thing (well, Codex/Claude mostly) using a rust graphics library (egui) and now the text is finally sharp! and its fast. I am growing more and more anti webview with these AI coding tools.. they can almost one-shot convert a slow webview app into something that uses 1/10th the ram and 10x as fast. The text looks soooo much better, all fonts look better. In xterm.js, text looks super fat all the time (to me).
You are asking for a look that’s very niche. Not many people hate anti-aliasing so much. GNOME still has a simple UI to turn off anti-aliasing but not many apps respect that. The modern text rendering pipeline is just way too complicated from font lookup, ligatures, shaping, etc. To achieve this look in web views you’ll most certainly need to do it in <canvas>. And of course, you can still choose to draw all the text using software rendering using JavaScript or use WebGL2 and ship it to the GPU: conveniently the constructor allows you to turn off antialiasing `canvas.getContext("webgl2", {antialias: false})`.
I predict a shift towards antialiasing being less desirable as DPI->inf. In my experience, disabling antialiasing dramatically improves sharpness and readability of small font sizes on modern 4K+ monitors, along with reducing eye strain and surprising bystanders.
1 reply →
You could also render the text inside a canvas in a web view, then you have a bit more control over the sampling. If you wanted to stick to a web view for some reason that is. Alternatively you could generate custom bitmap fonts on the fly based on the screen resolution.
Everyone is already pointing out this isn't quite software rendering but rather the rendering technique which used to be the only option. I'll add that even without a GPU, CPUs will have integrated graphics. There are CPUs that don't have this but in those cases you need a GPU. The point is that modern systems no longer use CPU to output to the screen, either there is an integrated GPU or a GPU card on the system. So in a way the term "software rendering" is only applicable to special cases of embedded systems that actually use CPUs for graphics.
I'm not totally sure what you're trying to say. Even back in the days of "software rendering" - or on those embedded systems that you're describing - you still had a piece of graphics hardware that converted the frame buffer into whatever got spit out to the monitor, so I don't think this is meaningful, really.
What's meant by software rendering is really software rasterization - the process of taking the triangles, textures, etc. of the scene and turning those into the pixels that eventually make their way to the screen. You can still do that in software on the CPU today without touching the GPU, even the integrated one. At that point you hand it off to the hardware to make its way to the screen, sure, but it's only an implementation detail that makes that different from handing 0xA0000000 over to the VGA card. The interesting part of the process, and the results, are functionally the same.
The difference is if it's hardware accelerated or not, or at least that's my understanding. Software rendering means there is no hardware acceleration. I think the term is outdated because typically it means you don't use the GPU, and this was true like a decade ago and earlier, but I think today CPUs have integrated graphics, so it's like they have tiny GPUs to help render to the screen because it's more efficient. So even if someone is not using a physical GPU, chances are the CPU still uses hardware acceleration, and that's why it works so well today.
I have an Intel i9 with no integrated graphics, if I don't use a GPU, the screen would barely render in very low resolution, although haven't really test it that. I can disable hardware acceleration in the browser and it spikes several CPU cores and is terribly inefficient.
Besides differences in texture mapping, the way GPUs render triangles is quite different to techniques commonly used in the old days. No one was computing barycentric coordinates and checking if every pixel was inside a triangle - it’s too slow to do that on a single thread. At low resolutions you get very different visual results because a GPU will not render triangles that do not cover the center of a pixel without anti-aliasing.
Precise and consistent fill conventions don't need barycentric coordinates, it simply needs some care in rasterization. Chris Hecker's 1985 texture mapping series in Game Developer covered how to do this properly in a traditional software scanline rasterizer. The necessary prestepping isn't expensive.
[dead]
Is software rendering the reason that people can run doom on everything?
Yes
Yes, although Doom isn't categorized as a real 3D engine as such.
What is Doom if it isn’t a real 3D engine? Is it faking it somehow?
4 replies →
A few years ago I seriously contemplated making a game using software rendering, in part because the only target was SDL. I actually got a 3D engine running 2K@60Hz with HL2-level scenes, with the CPU basically idle, so it's not a terrible idea.
(Then LLMs started taking off and I decided I needed to reskill out of the industry, just in case)
I know this is not entirely what this article is about, but I love software rendering for desktop apps. It seems to me that the performance impact with proper paint invalidation is negligible, but doesn't suffer from the same driver issues as hardware accelerated rendering seems to have. Bonus that it doesnt use any GPU resources in the age of AI
Its so interesting to me that back then we would have died for the graphics we have today, and now this retro look is being appreciated. I mean, it definitely has an aesthetic but its generally unappealing. I guess nothing is immune to nostalgia and pining for being at the age when we had less responsibilities and life seemed easier.
I guess thats one of the reasons of the success of Minecraft?
I remember when I finally saw my favourite 3D games (Quake 2 and Pod) on a Voodoo2 and I immediately bristled: I hated the blurry way the textures looked with bilinear filtering, and was iffy on their love of yellow lighting.
I've softened on the issue of non-white lights, but I 100% am still full of nostalgia about unflitered low-res textures.
Similarly, I really did prefer Playstation graphics to N64 graphics.
Michael Abrash's Graphics Programming Black Book is still one of my all time favourite. What they did back then was almost black magic. I learned a good part of maths, cs and physics trying to mod id1 with this book during my teenaghood.
Shoutout to https://www.jagregory.com/abrash-black-book/
The tech specifics covered have been out of use for decades. But, it's still a very fun read about thinking through the process of optimization.
That name brought back memories.
Unfortunately I didn’t do anything as impressive as modding a game; I read the book because the writing style itself was engaging and gripping like a novel.
I love Software Rendering too! I'd add Unreal Tournament to the list of "Games worth trying", though not sure what the multiplayer scene is like nowadays.
It should be pretty obvious that you don't need a Core 2 Duo to run Quake, which worked fine on a Pentium and some of the faster 486s.
Did you use any coding app to support you building the app? In that case, witch one is the one you choose and why. Thank you.
Sonic Mania (2017) actually uses software rendering to give it that retro look and feel.
Unreal Tournament also had a software renderer IIRC, with an interesting dithering effect.
Love seeing Blood mentioned, sometimes I feel like I'm the only one who played it
There are dozens of us! Dozens!!
There's Quake-SRP (the Slop Rust Port), code here: https://github.com/terrapapagalli1516/quake-srp
Playable in the browser (shareware version): https://quake-srp.pages.dev/
It's a faithful port of Quake's original software renderer. Everything happens on the CPU, which made it easier to match the original exactly. In theory the same could be done on a GPU, but I think it would be harder and messier.
The trade-off with software renderer is that it's more code. With GLQuake much of the actual rendering work is handed off to OpenGL itself, i.e. the driver and the GPU. In the software renderer, the engine does all of that in its own code.
I am still a big fan of CPU render for VFX (not games). It is stable, capable of very large scenes. GPU is fast but you will never render something really big. And CPU look is much much better.
> you will never render something really big. And CPU look is much much better.
Why do you believe these things? In VFX and film, the GPU shaders and rendering is identical to CPU, they use the exact same programmable shaders on either side, so there is no difference in look or capability. Today’s GPUs have out of core streaming and caching and access to host memory. Pixar showed off their pixel-matching between GPU and CPU at Siggraph this year, and mentioned that today’s consumer GPUs are big enough to render IIRC ~98% of their scenes without much ‘out-of-core’ tech. Lots of film and VFX studios are using GPUs in production today to render pretty big shots. I think your story is a bit out of date; GPUs being size limited was somewhat true in the past, but is quickly going away. The CPU vs GPU look question has never been true for VFX or film, and was only true in games if you chose different rendering algorithms.
I don’t know much about this so I’m curious. Is the reason why GPUs aren’t preferable for large scenes due to their limited VRAM or a different aspect of them?
UE5's nanite uses software rendering, but it doesn't look pixelated, does not need a high end computer, and does not require DOS.
“Software rendering” usually means “doing rasterization on the CPU”, as opposed to “hardware rendering” that is done by the rasterization primitives of the GPU.
Nanite is a bit weird because it doesn't use the hardware rasterization of the GPU, but it's still doing rasterization on the GPU, so it doesn't really fit this dichotomy.
Its probably not correct to state this. Its probably a combination of how nanite itself is doing Lob, lightning etc.
A mix of software and gpu
At this point words get blurry. Is using CUDA or a compute shader "software rendering" or not?
I call it "like software rendering". Its certainly software rendering in spirit since no fixed function rendering hardware is being used.
1 reply →
[flagged]
Eh, Nanite rasterisation is still happening on the GPU, it's "just" implemented in shaders rather than using the fixed-function pipeline. "Software rendering" is becoming less useful as a descriptor as graphics hardware becomes more general.
No software rendering requires DOS, you could use it with Windows back in the day (how I originally played Half Life) and engines that still support it will run on modern OSes too.
Is this why Doom is so portable?
yes
"I prefer the hum of tube amps, they sound so much warmer"
(And I actually do like their sound, but I wouldn't want to be stuck with only tubes)
I think Screamer looked great. Thief was another great software-rendered game as I recall.
Wrote a little software rasterizer for a roguelike years back and the best part was just being able to step through the whole pipeline in a debugger. No driver weirdness, no shader compile quirks, the pixel is wrong because your math is wrong.
Yeah, that is the hardest part about 3D graphics programming, at least it was the last time I had my elbows deep in it.
You're not doing traditional application programming once you get into 3D graphics. You are driving a microcomputer at arm's length. Every aspect of that challenge comes into play, from the fact that it's a black box to how you can have it working perfectly in one configuration of hardware, and then find it doesn't work on another configuration.
My favorite reasons for this include "there is a legitimate bug in the closed-source shader compiler" and "this graphics card advertises a capability but in reality it implements it in software so if you turned that flag on your render speed suddenly went to seconds per frame."
The CUDA era helped some with this problem because there was suddenly massive pressure on making the GPU into less of a bundle of pipelines and specialty hardware accelerators strapped together and more into standardized massively parallel fabric, because card manufacturers suddenly found themselves not wanting to be left out in the cold if they invested their time in building a very very fancy specialty hardware circuit for doing texture manipulation or something... And that proved to be useless for mining Bitcoin, or whatever they suspected might replace Bitcoin in the future. I think there are far less gotchas now regarding weird architecture than there were in the 2010s.
[flagged]
> Ion Fury, a Build engine game from 2019, still ships with a software renderer.
Amazing game BTW, best shooter I've played in many years. I never really got into build engine games back then, so it's not just my rose-tinted glasses, that game is a masterpiece.
Ion Fury uses a modified version of eDuke32 which can do software only rendering, and quite well, but defaults to GPU acceleration because Ion Fury uses the real time lighting.
That said, the Build Engine had software voxels in 1997. Which was pretty cool.
And for those who want more of this type of game I must absolutely recommend the game “Supplice” as well.
My understanding was they removed that software renderer specifically because it didn't run well.
It's still there, though I don't play with it. The characteristic Build mouse look distortion makes me queesy.
[flagged]
[flagged]
[flagged]
[flagged]
Anyone wants to tell him about CRT's?
Now that will truly blow his mind, at least on this setup and older games.
I don't think it really applies when we're talking about PC gaming. Consoles were blurry as hell on a huge interlaced low-res TV, but late-'90s PC games on a decent monitor had nice and crisp pixels on a CRT that weighed as much as a large dog. Especially when flat-glass trinitron CRTs and the like came out (yes spellcheck, that's a word), I don't think the end-user appearance on the screen was all that different from what we have now, other than obvious stuff like aspect ratio and incremental improvements to resolution and framerate. Maybe deeper blacks and lower latency on CRT.
The ability to shift resolutions natively was neat, though, I missed that in the pre-4K days.
Won't CRT's have significantly less latency and motion blur than an LCD... Oh yeah, and deeper blacks as you say.
Even the oldest and cheapest CRT monitor my family had was pretty pixel-accurate unless you were right at the edges. I was doing pixel art on it as a child and had no issues at all.