With me going it alone in development I only have limited resources at my disposal i.e one pc with which I develop and test the game. so I only know for certain my game works with that setup.

What options have I got in testing the game on the many different hardware/operating system combinations? Its a windows desktop game.

  • 4
    \$\begingroup\$ This has always been a big vague to me, so I figured a bit more discussion about it might be good. \$\endgroup\$ – Jari Komppa Jan 20 '11 at 11:04
  • \$\begingroup\$ Awesome question! I'm wondering this myself \$\endgroup\$ – Dream Lane Jan 20 '11 at 16:39

11 Answers 11


Off the top of my head I'd suggest trying to run the game on a few other PCs from friends or relatives. After that you might want to consider some form of beta test, i.e. publishing a demo or something so you can get community feedback.

  • 1
    \$\begingroup\$ Exactly. Just test on a wide range of lower-end machines. \$\endgroup\$ – David McGraw Jul 15 '10 at 20:23
  • 1
    \$\begingroup\$ Ok ... you are right but that is what can think out propably everyone. I really dont get why this particular answer has too many up points. No offense, it is completely right. \$\endgroup\$ – Notabene Jan 20 '11 at 15:44

One of my favorite ways to find this info is by using virtual machines.

Seeing as how you can configure the hardware and memory that the VM is allowed you can test a wide range of setups on your own PC. This also allows you to test across multiple operating systems.

  • 7
    \$\begingroup\$ The downsides to VM testing is that you're essentially always running the same clock speed and the 3D support is still fairly abysmal. They will help cover your bases in making sure your game works on 32/64-bit and the gamut of windows choices. \$\endgroup\$ – Error 454 Jan 20 '11 at 18:10
  • \$\begingroup\$ I do agree, while VM's cover a whole lot of bases, it does have limitations. Judging by the plethora of responses however I think the asker will be just fine ^_^ \$\endgroup\$ – Gerhard Davids Jan 21 '11 at 5:02
  • 1
    \$\begingroup\$ @Error 454 Not with ESXi, as described in my answer. You can actually control the amount of CPU and memory resources you want the OS to have \$\endgroup\$ – Ray Dey Feb 22 '11 at 17:06
  • \$\begingroup\$ @Ray Dey sorry, not true, ESXi gives you a virtual SVGA, there is no direct access to your video card: kb.vmware.com/kb/1011942 \$\endgroup\$ – Error 454 Feb 23 '11 at 17:41
  • \$\begingroup\$ @Error 454 I wasn't certain about the video capabilities, so I didn't comment on it. I should have made it clearer. But thanks for clearing that up for me :) \$\endgroup\$ – Ray Dey Feb 23 '11 at 17:44

You should have some rough idea of the minspec just by developing your game -- for example if you made an explicit choice to use D3D10+, you obviously are culling out XP machines. So that's a place to start.

Find a way to test on as many machines as possible, ideally after implementing some way to gather performance metrics automatically (as users can be unreliable) as well as non-identifiable information about the machine the game is running on (processor(s), core count, GPU type, RAM, OS, et cetera -- take a look at the kind of data the Steam Hardware & Software Survey collects). One of the best ways to do this is to give your game to friends and family, as has been suggested many times already. Another way might be to approach a community of hobby game developers and see if they are interested in testing your game. I'm not sure such a thing would be an appropriate question here on GDSE, but you could probably find a few people in the 'chat' area and you could also look around/post on websites like:

All of those websites have forums or sub-forums dedicated in some way to showing off games, and so you might be able to get a reasonably good response out of them. I would make sure to disclose up front whatever statistics your game collects and/or sends you though, and why you are collecting them. People can get annoyed by that if they discover it after the fact.

N.B. that the Steam survey is also a useful tool in itself for gauges what a minspec should be -- it can help you see what the cost/benefit ratio of supporting a particular feature or class of hardware might be for you.


- How much RAM it uses
- How much texture + GPGPU memory it uses
- Minimum frame rate / Current frame rate * CPU speed * SpeedUpFactorOf(minimal number of cores you can use)
- Similar equation for GPU calculation units
- what level of opengl/directx/cuda your game engine requires from the graphics adaptor
- how much disk space the installation + user info takes...

Also test on various hardware configurations.

  • 2
    \$\begingroup\$ For most software, that relationship between number of cores and frame rate is not linear. \$\endgroup\$ – Ponkadoodle Jan 21 '11 at 1:34
  • 2
    \$\begingroup\$ This relationship also implies that game is CPU limited, which is not true often. \$\endgroup\$ – Kromster Jan 21 '11 at 6:29
  • \$\begingroup\$ I meant that as a general direction - each programmer should check what technologies he/she used and what resources they depend on. I slightly amended my answer. \$\endgroup\$ – Danny Varod Feb 22 '11 at 16:39

Basically you want to test on as many other machines as you can - from your friend's hard-core gaming rig to your gran's email-and-internet-only machine. Especially your gran's email-and-internet-only machine, because it's probably loaded with cruftware and other stuff that will interfere and slow your game to a crawl.

PC compatibility testing is a big nasty can of worms, and there's a reason why professional testing is expensive. So you want as many different odd scenarios tested as you can.

Beta testing is the way to go I think, both with friends and family and a wider circle in your fan community. Key thing - don't rely on anecdotal reports. Your friends might be relied on to actually reply, but the wider community will not, unless you make it easy for them.

Build logging into your app to give you hard facts on FPS, startup time, etc. Give the user an easy questionnaire, ideally built into the game, where they can report whether or not they though it played okay. And have those statistics and logging easily emailable / transmittable back to you, for you to pore over later. The more stats you get back, the better a sense you can have of whether your title is a) working at all on other systems, and b) working well on other systems.


Test on as many PCs as you can (that will also help you to catch all specific bugs). As developer you should know your main bottlenecks - focus on stressing them. You may ask your friends, colleagues at work, girlfriend, parents, lots of people in forums.

P.S. Just for reference:

  • CPU requirement = run game in minimum resolution or with no GPU rendering at all (I hope the render code utilizes minimum of CPU)
  • GPU requirement = run the game on powerful CPU with default resolution and see which GPU is sufficient of doing the task, also mention minimum Direct3D/OpenGL version
  • RAM requirement = how much RAM does the game takes (e.g. via TaskManager, with VM size column, to see all allocated RAM, not only active)
  • Sound = almost anything fits, just mention 2 / 5.1 channels support
  • Display = specify minimum playable resolution where game controls fit
  • Network = some massive load tests and see which bandwidth allows it (56k modem, DSL, T1, LAN)
  • Keyboard/Mouse/Tablet/Joystick, etc..
  • 2
    \$\begingroup\$ After getting those figures, you would certainly want to increase them slightly, in case your game was running at a low memory usage. \$\endgroup\$ – The Communist Duck Jan 20 '11 at 16:46

For requirements, I would assume minimum things required to run you game. It will depend on what technologies you use to develop your games.

For example, if you use specific APIs, such as D3D9 or OpenGL 3.0, you will need to specific that, because certain APIs are not downward compatible.

If you build with windows with .net framework, you will also need to specific that as well.

For performance requirements, trying on different machines are pretty much the best way to go, though you may be able to measure the related performance by calculation.

for example, if your current video card runs at 60 fps, and another computer with the similar configuration, except the video card is half speed of yours, should run about the half speed of your machine. Again, this is just an estimate, many others properties will hit the performance differently, but you can use that base info to test your game on targeted devices.

Hope that helps, and anyone is welcome to correct me for any reasons.


Depending on your target market (I assume it isn't cutting edge 3d ie. expensive graphics cards needed), I'd look at picking up a selection of older graphics cards from somewhere like EBay so that you can test on both NVidia and ATi cards.


It is always perfect get comunity feedback as mentioned. But where to get community and people who will try to test it? Posting it on some indie games forums will help, but problem will be to get actual feedback.

Only few percent of people who will test a game it will write you their exact configuration and problems that ocured. People just dont do that. Much better way is enable some kind of benchmark with reading users system configuration. Ask user to run some one button benchmark. Offer some numbers and times(yeah people like it :-)) and let him compare with other users (with sending data) ... It will help.

And then you have database full of configurations, screen resolutionn, render times and failed features...

If you are on windows calling DXdiag will help you read the users configuration. But there are some programs you can use on other systems.


As mentioned by others, the best way is to get the a beta out there and gather community feedback to get reliable results.

I'd also like to suggest the use of ESXi. It's a Virtual Machine solution from VMWare. Don't be put off because it's a VM solution. ESX is a lot more low level.

This would probably be ideal to you since you have one machine. You can test different operating systems, hardware setups (bar the graphics hardware, ESXi would use whatever you have installed on your machine).

It's basically its own very slimmed down operating system that you can install other operating systems on top of. We use it at work for compatibility among a great deal of OS's. It's very fast and reliable, almost as responsive as a vanilla machine.

I know hardware requirements is what you're looking for and ESXi has a very nice feature where you can limit the amount of RAM, CPU or disk space usage by the operating system and could potentially emulate how your game would run on anything from a low end CPU or low memory, to top-end CPU or memory use (limited by your actual hardware).

So if you had quite a high spec PC you could install ESXi on it, install whatever operating systems you wanted to and play around with the CPU and Memory usage (I believe you can even modify the number of cores the OS uses as well!)

Here's a link to it: http://www.vmware.com/products/vsphere-hypervisor/index.html

Best thing about it? It's 100% free!


Running some kind of profiling tool would be one way. For Java programs you could use VisualVM (https://visualvm.github.io/). Wikipedia lists some other ones. See: https://en.wikipedia.org/wiki/List_of_performance_analysis_tools. The same goes for debugging memory. See: https://en.wikipedia.org/wiki/Memory_debugger

Basically this amounts to checking your memory and CPU usage at some regular interval while running the program/playing the game. Then you calculate some average range and that's what it needs most of the time. Ideally this would be automated (for consistency and accuracy) and you'd want to exclude the amounts of those resources consumed, shared, or used by other processes. There might be some priority issues hiding the fact that your program might use more memory if it was available. I.e. if the OS was super busy your program might founder a bit from having not quite enough memory.

Ultimately you have to test/benchmark/profile and then analyse those tests. It's good to have a pre-defined performance metric to compare to. E.g. in an FPS you might want 30+ FPS for playable/enjoyable gaming. Based on that you would set the minimum bar at/above the hardware specs needed to meet that 30+ FPS some percentage of the time (it's always possible for the user to run too much at once and cause crashes and hangs).

As others have said, you really need other people to test it on a range of different hardware. In an ideal world you'd have a bunch of groups with similar hardware within a group and conduct some kind of control vs. experiment testing to see if more/less memory, cpu, gpu mattered when the other factors were held constant.


Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.