Sometimes it really really hurts to have the drive and desire to keep reinventing the wheel, although I think if I were "in the industry" and not umbilically attached to my "this sounds like a cool thing to study" mindset, I would be a lot more progressive and, by extension, exponentially more productive.

On the other hand I can say I've had a fairly intimate look at pretty much all aspects of a PC game as a result. To me that accounts for something.

I bake bread. I'm not trying to run a commercial bakery, I just like baking bread and I enjoy making something for my family or friends. But I didn't build my own oven or assemble my own mixer, because right now, those parts of the process don't interest me.

^^^ This. I don't use engines because I find there is so much junk surrounding what I need that it's easier just to make it myself. But that's for small, one person stuff. You can't run a game company by telling everyone to go and write everything from scratch.

And yet, all those rock-star engines today started out as yet another engine built from scratch because all the other stuff was crap. Now they are selling them.

What ever the new cool thing 10 years down the road is, it isn't coming from some mod to an existing engine, but from something completely different.

Why bake bread from scratch? Why not buy a loaf?

I make my personal code from scratch. I avoid loafs that contain genetically modified crops, cancer elevating sugar, undead yeast, artificial...

When people play my code, I simply want them to be safe.

Btw, inventing a wheel makes you smart. Using a wheel is also smart.

You all have thoroughly elaborated on this complex. I totally get the Tuna analogy! hehe.

As many of you say, I am also facing the documentation issue. Before this engine I used an engine that had an intutive API (which made up for the lack of documentation), but it did not have the features I needed. Now this current engine has all of the features I could ever want, but the documentation is lacking, and the API is not as intuitive.

Yet, I still can't do the "from scratch" thing, because as someone noted, technology is always changing.

I try to always make the style of my code very modifiable (variables at the top of the file). I don't always comment "my" code, but I should etc.

My cousin and I have a joke, "how much more do we really need to upgrade the hammer?"

And yet, all those rock-star engines today started out as yet another engine built from scratch because all the other stuff was crap. Now they are selling them.

Didn't Valve's engine series grow out of taking an already good engine and improving it for their own needs? Not as rockstar now as their last major release was awhile ago, but great software doesn't rely on being built completely from the ground up. How many game engines are built around strong support for physics middleware?

Great software isn't born out of nothing. Great software is born out of experience with past software and code.

And yet, all those rock-star engines today started out as yet another engine built from scratch because all the other stuff was crap. Now they are selling them.

Didn't Valve's engine series grow out of taking an already good engine and improving it for their own needs? Not as rockstar now as their last major release was awhile ago, but great software doesn't rely on being built completely from the ground up. How many game engines are built around strong support for physics middleware?

Great software isn't born out of nothing. Great software is born out of experience with past software and code.

Well yes, you are right. I don't want to go and write my own graphics drivers, physics code, sound code, font code, etc. It depends on your definition of "from scratch", which is arbitrary. I use OpengGL, SDL, Freetype, OpenAL, and some other stuff. Is that "from scratch?"

Experience with past software and code isn't doing us any good if don't keep trying new things and improving what we already have. But yes, these engines weren't built from nothing. (I don't really know that, I'm just guessing)

I would say that I'm a "From Scratch" type all the way.

I like to have full control over the things I do. This extends to "I NEED to have full control over the things I do" if there is anything mission-critical involved. The latter is not always possible when using 3rd party code.

Another point that's great about writing stuff from scratch: you will learn a lot.

And that's a huge benefit in situations that might force you to decide whether to write the thing from scratch or go with an existing solution. The reason for this is that your knowledge empowers you to take several things into account that you might not really know about if you weren't writing something similar from scratch in the first place. You are even able to compare existing solutions on a more fine grained level which is always a good thing if you're trying to find something that fits your needs.

It would also be great to hear from people that were mainly using 3rd party solutions on projects that failed by doing so. (What are the reasons for this?)

By nature, I am a from-scratch person. In addition to the enjoyment of doing stuff yourself, this probably comes from starting in the old times (C64) where you for example needed to write your own music editor & player to make sure the music would not take too much resources.

As time has passed on, I've accepted using third party solutions for small, isolated problems like image loading. And for things that so far go over my head, like 3D rigid body physics.

When working professionally, there's often not the luxury of time / resources so you may have to take 3rd party libraries or frameworks for even larger problems, and they become part of your application's identity. For example basing your application on Qt's UI, metaprogramming and scripting, which turns out not to be a good idea if you want a performant 3D toolkit.

Something that I'd consider a more devious case is for example the choice of whether or not to use SDL for crossplatform graphics context initialization & input. SDL is a proven solution, and I'd argue the problem it solves is small enough, but by using it you don't learn each underlying platform's specifics, and if it turns out SDL doesn't work right on some platform in your specific case, you can be in for a lot of sudden learning and pain.

If the end product you're writing is a game, you're probably more justified in just using whatever 3rd party libraries get the job done. However if you're writing an engine or toolkit for others to use, you'd better be able to vouch for all the libraries you're using, and understand them on a fairly deep level, because the support for the whole combination will still be up to you.

And yet, all those rock-star engines today started out as yet another engine built from scratch because all the other stuff was crap. Now they are selling them.

Didn't Valve's engine series grow out of taking an already good engine and improving it for their own needs? Not as rockstar now as their last major release was awhile ago, but great software doesn't rely on being built completely from the ground up. How many game engines are built around strong support for physics middleware?

Great software isn't born out of nothing. Great software is born out of experience with past software and code.

Yeah, Valve's source engine is built upon the foundations/rubble of their GoldSrc engine, which was built upon the foundations/rubble of the Quake engine (which was shaped by their experiences on Doom, and so on).

Even Unreal 4, as much of a "rewrite" as it supposedly is... it's still built upon the foundations/rubble of Unreal 2 (which is built upon Unreal).

My current engine is "from scratch", but while the source code is new, a lot of the architectural ideas behind it come from all of the companies that I've worked at, and early engines that I modded with, such as Quake... so in that sense, I'm still standing on the shoulders of giants.

The fundamental question is simple: do you care about making things for other people, or do you only care about yourself?


If you are only in it for yourself, and I don't mean to judge that in any way, then go for the NIH, from-scratch, control-freak obsessive need to write everything you can imagine by yourself. Seriously. If you have no goals other than your own enjoyment, pursue what you find most interesting. Do it! Have fun!


Now that the hedonists are out of the way: what if we want to make things for other people to use?

There are two options:

- Code exists that is sufficient for doing what you need
- Your needs are so unique and demanding that nobody else has done it before

I'm willing to bet that 95% of the work done in the non-commercial software world actually falls into bucket #1. If you fall into that particular bucket, not trusting someone else's code is just silly. Remember, the point isn't to masturbate over how clever we are, it's to build something for someone else to use. If that weren't true, you'd be covered by the first part of this post.

Suppose you hire a contractor to build you a small shed. He agrees to your plans, and returns with a proposal: twelve trillion dollars and four hundred million years.

You're going to politely ask what the fuck is wrong with his brain. We're talking about a garden shed, after all.

Well, this particular contractor wants to create a miniature star, forge his own raw elements, place them in a vacuum, and allow them to stew until life spawns, then evolve a particular strain of tree that has wood that happens to be the color that you wanted to paint the shed.

Why?! you demand of this clearly demented soul. Why do this?

Because those paint guys, they don't know shit, they probably fucked it up and the spectrum of light reflected by the paint is off by a few microns or whatever, and blah blah blah.



That contractor is what you sound like when you insist on writing things from scratch, while pretending to have the goal of actually shipping code.