Awesome Engineering Games (github.com)
I've spent way too much time both playing and finding engineering-focused games, and haven't been able to find very detailed or comprehensive lists online. So I made one :)
These games are both fun and often quite educational, presenting gamified versions of real-world challenges and professions.
There's a lot of different sub-genres of "engineering game", such as:
* Factory automation (Factorio, Dyson Sphere Program)
* City builders (Cities: Skylines, Anno series)
* Route-builders (Mini Motorways, Railway Empire)
* Comp sci (TIS-100, Bitburner)
All games on the list are very highly reviewed. I've played most (but not all) of them, and provided personal recommendations alongside the reviews. Many of them are also playable on GeForce Now (if you don't have a gaming PC).
Please contribute if you know of more, or have any comments/suggestions!
145 comments
[ 2.5 ms ] story [ 212 ms ] threadCan't wait for the 2nd one :)
It’s abandoned and available for dos box as well but the web version is easy to get started with.
If these older games don't get added there, it might be worth creating a sibling list that this one can link to?
but this ``` I say keep it to just Steam games. That way if nothing else it has the focus to be an amazing utility and still has plenty of items to curate. Once the criteria becomes "everything under the sun" it becomes so huge that it's likely to have a low signal to noise ratio for usefulness. ```
seems like a pretty reasonable stance. Completely fair to say if people want old games, go look for old games.
https://store.steampowered.com/app/375820/Human_Resource_Mac...
might be worth adding this and 7 Billion Humans
https://store.steampowered.com/app/792100/7_Billion_Humans/
https://www.gog.com/en/game/human_resource_machine
https://www.gog.com/en/game/7_billion_humans
also gog has WHILE TRUE: LEARN()
https://www.gog.com/en/game/while_true_learn
because how many games expose you to machine learning?
What I do know is that it was making me solve problems - at a high level - differently than looping/if-then-else kinds of things I did in other games.
Personally, it is entertainment to me, and I won't point the finger because it was fun.
Mobile apps , I'm tired of playing bridge builder.
https://i.redd.it/dpcixz3z60d81.png
Back in the 1.4.7 days the biggest packs out there were kitchen sink packs like MindCrack with GT3 being the biggest single mod. The gregtech family tree has grown substantially and the largest branches are much more intricate than what used to be around. On par with Krastorio2.
The entire factory game genre owes its existence to Minecraft mods.
It has one of the best mechanism simulators I've seen in a game with all sorts of gears, differentials, slider joints, springs etc. I've found it handy for virtually prototyping, you can mock up and test machine concepts much faster than CAD software.
Oh and it has a python API: https://docs.roboco.co/latest/
May I please cite your comment as a recommendation and link to this?
(the ceiling on the game this is an installment of is pretty high, eg https://terrytao.wordpress.com/2023/11/18/formalizing-the-pr... )
I had a lot more fun with incredible.pm; a lot of the difficulty in the Natural Number Game was in the UI being unclear. For example, I ran into a case where I had y <= d and I wanted y <= d + 1.
The two relevant theorems here are the transitivity of the <= relation and the fact that n <= n+1 for all n. Both of those were in my "inventory". But I had no way to apply them.
In incredible.pm, you'd have a block for "n <= n+1 for all n", you'd run that through a universal instantiator, and you'd get d <= d+1 as a result. Then you could use that as input to the transitivity theorem.
But in the Natural Number game, where I had my hypothesis y <= d and my goal y <= d+1, there was no way that I was aware of to introduce the result d <= d+1, even though I had access to a theorem proving that specific fact. The solution turned out to be to say "apply le_trans" [to the goal y <= d+1], which gave me the intermediate goal y <= ?succ.inr.h.y . Hovering that upper bound then says "[This] Parses a synthetic hole [...] This syntax is used to construct named metavariables."
Then, guessing something that might work but that the game certainly doesn't teach you to do, I closed that goal by calling "exact" on my hypothesis that said y <= d.
This works† and unifies the value d with the named metavariable ?succ.inr.h.y . But I would not consider it a triumph of user experience.
incredible.pm is also better in that it provides a playground where you can set up your own proofs of arbitrary theorems.
† Well, the call to exact works. The call to apply le_trans split my goal "y <= d+1" into three goals, which were "y <= ?succ.inr.h.y , ?succ.inr.h.y <= d+1, and, for no reason I can imagine, ℕ. However, proving the first two goals completed the overall theorem, so I still don't know what it meant to have a third goal of "ℕ".
(that said, I liked NNG better because (a) the sequence felt more like actual theory* building than figuring a few cool puzzles, (b) I much prefer the textual input —even with the "guess the verb" problem— to clicking and dragging wires and blocks, and (c) I feel like I've learned something about how to use Lean, while it seems unlikely I'd be able to transfer much from the UX of incredible.pm — maybe if I'd tried 'modding' it I'd feel differently?)
Maybe a fair way to put it is that the NNG is like ice hockey: for it to be fun at all you must first enjoy skating?
* the old, Lean 3, NNG had as its crux "trichotomy for ℕ"; that was very satisfying to finally prove!
There is some of this in incredible.pm, and there's some of it in NNG. I made very little use of previous results in either one, except for a few levels of NNG that shame you for not generating simple proofs from immediately previous results.
incredible.pm's "gameplay" element where you're challenged to prove the theorem in as few statements (blocks) as possible works against the idea of developing a bank of theorems and then applying those theorems to prove other theorems. I'm not so fond of it.
> (b) I much prefer the textual input —even with the "guess the verb" problem— to clicking and dragging wires and blocks
That's fair. The bigger issue I have is that in incredible.pm you're free to make statements if you think those statements will be useful to you, while NNG is very strict about making you work with only the statements you're given.
In fact, there is one level in incredible.pm where I solved it in what was listed as the minimum number of blocks, but one of those blocks was a label. The label block is not doing any logical work, but sure enough, if I deleted the label block, incredible.pm was unable to unify the output that I had routed into the label block with the input that I had routed the label block into. So it would appear that at least one of the levels in incredible.pm specifically expects you to introduce your own statement with your own phrasing as an aid.
> (c) I feel like I've learned something about how to use Lean, while it seems unlikely I'd be able to transfer much from the UX of incredible.pm
I should be fair to NNG: I had extreme difficulty using existential statements correctly in incredible.pm, and more moderate difficulty managing to correctly use universal generalization. I think solving those levels gave me at least a decent mental model of how the theorem prover was handling quantifiers internally, and that should have transferred to a textual interface -- although it hasn't really stuck in my mind.
> the old, Lean 3, NNG had as its crux "trichotomy for ℕ"; that was very satisfying to finally prove!
That's still present in the current NNG. It is the proof I spent so much time complaining about above, the final level of Inequality World. (Or rather, that level wants you to prove that any two natural numbers are comparable, but you must use the trichotomy in order to do that, and you can't use what you haven't proved.)
--------
I think NNG would benefit a lot from including more difficult proofs. (And from letting you introduce your own intermediate goals!) I was proud when I finished the proof that ∀x.(r(x)→⊥)→r(f(x)) ⟹ ∃x.r(x)∧r(f(f(x))) . I had to think about what the theorem was saying and write down a plan of attack. NNG doesn't really have anything like that.
--------
Something I really did like in NNG was the remarks about (and eventual proof of) injectivity of the successor function. It's very interesting to me that the proof is based on, as NNG describes it, "the mathematically pathological pred[ecessor] function" - but only on cases where the pathology doesn't exist. (The proof involved introducing the function, making it inaccessible to the player, and instead giving the player the theorem "pred succ n = n", which is true without any exceptions.)
Cool; it wasn't there yet 6 weeks ago: https://news.ycombinator.com/item?id=37880788
"pred succ n = n" reminds me a lot of def'ns of the form "(left p, right p) = p"; I'll have to think about that a bit. Injectivity of succ is, I guess, what distinguishes ℕ from similar constructions with different characteristic? (did I just think that, or am I parroting NNG?)
> ∀x.(r(x)→⊥)→r(f(x)) ⟹ ∃x.r(x)∧r(f(f(x)))
I think I gave up on incredible.pm too early (although I did skip ahead for SKI) ... I'll have to go back and try that. It seems to have a bit of the flavour of "all people who claim to be Sir Anthony Charles Lynton Blair KG are liars"
NNG gives you the pred_succ theorem, and calls it a theorem, but I don't see how it's supposed to be proved. Suppose the successor to 9 were 3. What's stopping that from being the case?
I don't see that pred_succ ("pred succ n = n" for all n) is a lemma from which succ_inj can be proved - it looks to me like pred_succ is logically equivalent to succ_inj. Each is true if and only if the other is.
Here the problem is not so much that the pred function is mathematically pathological as that the axioms, without the axiom that the successor function is injective, do not allow us to define a predecessor function at all. The guarantee that when, you call succ on nine, you don't get a number that is also the successor of some other number -- which is necessary in order for pred_succ to be a valid theorem -- is precisely the statement that succ is injective.
Am I missing something?
I was very wrong earlier: characteristic is taken care of by 0 not being a successor; injectivity of succ also allows circular pseudo-nats.
PS. found Peano (1889): https://archive.org/details/arithmeticespri00peangoog/page/n...
This is prevented by saying that the successor function is a function. If a = b, then S(a) necessarily equals S(b). (The other half of axiom 7, the statement that when S(a) = S(b) then a = b, is the definition of an injective function. It's what prevents us from saying that the successor to 9 is 3.)
There is a fun image of dominos on the wikipedia page for the Peano axioms that explains how the structure of the natural numbers is constrained by the axioms.
A backwards loop from a number in the chain of succession from zero to an earlier number in the same chain can't happen because the successor function is injective.
A backwards fork (two chains meeting) can't happen for the same reason.
A forwards fork would be invisible to us as long as our only available tool is the successor function, which will always choose the same branch of the fork. This essentially means that forwards forks don't exist. There could be a larger structure in which it is true that e.g. the "9" node has one outgoing edge pointing to "10" and another one pointing to "green", but only one of those edges can be the edge picked out by the successor function, so our structure would only include one of the "10" or "green" nodes.
A loop parallel to the chain of succession from zero [imagine the normal chain "0, 1, 2, ..." alongside the three special elements 甲 乙 丙 arranged in a three-element circle] is ruled out by axiom 9, which says that any set that contains the chain of succession from zero contains all the natural numbers.
thinking out loud...
we are free to define a predecessor function by saying it is the inverse of the successor function. That definition would immediately prove the pred_succ theorem, as long as the successor function is invertible. Half the definition of being invertible is being injective, so this doesn't let us prove succ_inj in a non-circular way.
I don't know how else we would attempt to define the predecessor function, given the algebraic structure we're working with where all values take the form "0" or "succ n".
There is a discussion about it here: https://github.com/arcataroger/awesome-engineering-games/dis...
Maybe there could be a sibling list that compiles all the non-Steam ones?
It has a very steep learning cliff, but once you learn it you can build all kinds of war machines, from ships to robot walkers and spacecraft. And you create the individual systems which your vehicles use as well, such as steam engines, weapon systems, AI, etc.
Its a game I've spent many hours in.
https://www.zachtronics.com/ruckingenur-ii/
Poly Bridge is also a game that is focussed on building bridges.
Kerbal Space Program is focussed on constructing a Rocket and launching it.
On one hand, if we add Civ, that would probably open up all 4X games (Stellaris, Sins of a Solar Empire, maybe even Age of Empires, etc.). That might be a lot of games, and arguably the "engineering" isn't a huge focus in those games. From what I remember, those games don't have a whole lot of automation/assembly lines going on, or focus on route-building (Civ has roads, but it's only a minor part of the game), infrastructure, etc. It's a pretty big-picture view nations, rather than the day-to-day nitty-gritty of running individual cities/settlements.
On the other hand, it could also be argued that settlement games are similar too, just a matter of degree or "zoom level".
I'm on the fence about it. Any thoughts?
-----
Oh, and Poly Bridge and KSP are on there already :)
Discuss the thoughts at the top of the GitHub page so that your thinking and criteria are clear of why certain games are included an others are not. It's completely fine to exclude Civ -- it is kind of a unique game that aims to include many aspects of ancient and modern Civilizations from military conquest to scientistic research to engineering achievements. You could argue it's an aspect of the game but not a central game mechanic which the list aims to promote.
Don't over think it though -- it's just a list of games that supposed to be useful to whatever audience you have in mind. I'm just trying to rattle off suggestions anyhow and that makes the list better given many games were 'considered'.
https://boardgamegeek.com/boardgame/13354/car-wars-compendiu...
Players spend some "homework" time designing vehicles, then they test them in turn-based combat, then it's back to the drawing board to revamp designs. For every hour of combat play, it's probably at least one hour of design time, tweaking designs within constraints . . .
Starting with version 5, they started dumbing down the rules and focusing more on faster combat and moving around larger toy cars instead of designing anything. Because who wants to play a geeky engineering game, anyway? (me)
One game that I really got into for a bit was Autonauts [1], but ended up falling a bit short of what I was really looking for (due to very awkward UI and controls).
But would really love to see more games with automation (like Factorio) but where the automation was coded. Or tower defense/RTS games (like Mindustry) or simulation (like Rimworld) where you could automate the AI.
I see some games involving coding, but mostly look like hacking games, which I think are more puzzle games, vs. sandbox.
Like I said, Autonauts would have been this, but it’s just too awkward, and not quite as deep as I was hoping.
I was excited this was such a list, until I realized it wasn’t software engineering.
(My very first experience with something close to this was FFXII, which I loved, but fell flat for many because they didn’t want to automate the battles, which was my favorite part!)
[1] https://store.steampowered.com/app/979120/Autonauts/
You write the code for each of your units, either natively in Javascript or Typescript, or via WASM you can run Rust, Python, etc. You use a private server or join a shared MMO world. There's a free sim [1] to try out the basics, though the actual game has much more depth. And an active Discord for help [2].
There's also a variant Screeps: Arena [3] that focuses on 1:1 PVP battles with ranked ladders if you prefer short-lived matches to a long-running world.
[0] https://store.steampowered.com/app/464350/Screeps_World/
[1] https://screeps.com/a/#!/sim
[2] https://discord.com/invite/RjSS5fQuFx
[3] https://store.steampowered.com/app/1137320/Screeps_Arena/
On one shard you can't use more than base CPU, so there's no advantage to a subscription there.
Other optional shards are almost entirely people who subscribe. Do that too if you decide to, or ignore them.
> I was excited this was such a list, until I realized it wasn’t software engineering.
SpaceChem is a programming game, and it's on the list, but it's not categorized under Hacking, Computer Science, Logic, and Automation, which would have been the correct category. It's listed under Puzzle & Casual instead. Opus Magnum has the same problem.
SpaceChem is more "programmy" than Opus Magnum. Do you like writing Befunge?
It's a long and rather hard game, but I liked its learning curve. You'll need to understand the way the "world of the game" works, then define and code a strategy. Then other "worlds" appear, where other strategies are required. I enjoyed playing it and I have 5k lines of TS code in my Git repository for bitburner.
https://play.elevatorsaga.com/
Do you think Bitburner, Exapunks, while true: learn(), TIS-100, and Screeps would belong there too, or do you think a category specifically for "Production automation via code" would be more helpful?
PS That category just sounds like work you can get paid for, lol :)
I think Factorio was early access longer than necessary, and Satisfactory also feels like it’s well beyond “early access”.
E.g. it’s not like “early access” means that they’re still making changes to the game, and stop making changes once the label is gone. I’ve seen “early access” games get abandoned (or even never see another update), and I’ve seen games out of “early access” still continue getting several updates.
That seems to be the clear line between "early access" and "Updates past 1.0": are you backwards compatible? Before 1.0, you don't have to worry about that, but I'd be very annoyed to find a new mountain in the middle of my base come 1.1
However it is unfinished by virtue of the fact that they have a lot more planned, and it's early access by virtue of having resources in the world with "WIP" in their tool tips.
Sorry, the dates weren't meant to be a competition, and I just pulled whatever Steam listed it as! If you know of any other games that have an unfair date, please let me know :)
My daughter loves Minecraft and the house building games on Roblox, but trying to find something a little deeper but still fun..
https://animalcrossing.nintendo.com/new-horizons/happy-home-...
[1] https://store.steampowered.com/app/497780/Recursed/
Scheme-stained glasses will translate these mechanics as follows: a chest is a function and a visible room is a scope formed by a function invocation. So it is obvious that entering the same chest again won't (mostly) keep existing objects and nested rooms have distinct states. As the game progresses, you will find various objects that interact with typical function scopes, and many of them have analogies in Scheme or similar languages. For example, I think there was an object that corresponds to an one-shot continuation!
TerraTech (https://store.steampowered.com/app/285920/TerraTech/) for the vehicle building category. Very streamlined and surprisingly deep, although the campaign gameplay can be frustrating.
Workers & Resources: Soviet Republic (https://store.steampowered.com/app/784150/Workers__Resources...). A planned economy city builder. It's apparently an extremely deep game with a steep learning curve. Seems to have developed a cult following.
Basebuilders seem to divide into two rough categories: ones where things you build appear immediately (e.g. RCT2), and ones where minions have to go and install what buildings you command to be installed (e.g. Evil Genius, Factorio's robots).
Recommendations for interesting basebuilders are always of interest.
While we're on the subject: games with level editors (particularly those with some kind of scripting system) are kind of interesting as even if the gameplay isn't "engineering", you can get sucked into level design. DROD comes to mind. A list of games with level editors would also be interesting.