Lets talk about Source Code

Posted by (twitter: @mikekasprzak)
December 19th, 2012 3:33 pm

So earlier this afternoon I sent out a quick poll to the Ludum Dare twitter account. The premise was simply, should the Ludum Dare Compo (48 Hour solo event) require source?


So yes, as it turns out a significant number of people like this requirement (or are indifferent). Drilling down in to the reasons people like this rule, we get the following:

  1. It’s a good reference for new developers
  2. It encourages community
  3. It lets us verify that somebody didn’t cheat (**)
  4. It keeps people honest
  5. It can solve disputes (**)
  6. Some broken games can be fixed with just a few source tweaks
  7. I like to look at how people implement things
  8. Source code is one of the best things to learn from
  9. Any code created in 48/72 hours wont contain any serious secrets
  10. Even if it’s not you, somebody will learn from the code
  11. Ludum Dare is about Learning

And some of the reasons against.

  1. The code is often messy and not a good example of proper game code
  2. I use a proprietary engine. I can’t release its source.
  3. Some tools can’t easily export source
  4. Code can be stolen, games can be illegally published
  5. I like to make games and sell them later
  6. Unity/Flash users get lots of features and only have to share game code
  7. My code is mine

I was actually surprised by the overwhelming response, so to make sure we didn’t have skewed results, I added a 2nd question about half way through the poll:


So about 60% have looked at source code, and 33% have learned something from it. All things considered, that is a significant number.

The data says something else too.


I didn’t ask specifically how much source code people have looked at, but one fact I will share is that in the 10 years we’ve run Ludum Dare, we’ve never had to take action because of what was found in source code. I can’t remember any questionable games ever making it in to the top games. Funny enough, many real disputes have been complaints about people forgetting source.

Now as you all know, Ludum Dare very big now. The idea of us policing entries is well beyond what we can do. We don’t actually have prizes, so there’s really no reason to cheat at Ludum Dare. So the old policy of “to stop cheaters” really didn’t make a lot of sense to me anymore.

That said, there’s a lot great reasons to continue requiring source. The Jam has never required source, and that has been one of our main ways of inviting more people to participate in the event. That will not change. But where there may be room to change is why source is required. So, to quote myself:


Of course, if disputes do happen, having source gives us something to make a case with. Innocent until proven guilty is kind-of a nice policy after all. So perhaps the main reason we share code should change.

Here’s another thought:


Now there’s an interesting twist. One of the classic complaints of “From Scratch” developers versus Unity/Flash/GameMaker/Middleware developers is the sort of “unfairness” that they have to share so much. It is an issue we let happen, and it is true it’s not fair. So alright, Matt’s idea provides a fix to that long long problem. Not to mention, #2, #4 and #6 in the “No” list. There’s nothing stopping you from submitting everything as usual, but it gives more liberties to those that are protective/unable to share their engine code. In contrast, it does mean fixing code for some entries (Yes #6) is not be possible (extremely cool but uncommon anyway).

So that’s what’s being considered. Again, we really don’t have the time to police thousands of entries, so the thought is to redefine why we ask for code, and perhaps what we ask of code.

Share your thoughts in the comments.

39 Responses to “Lets talk about Source Code”

  1. Kroltan says:

    I like having source code, because I can learn how people do specific things.

  2. HackThePanda says:

    One of the reasons I like this competition so much is that it requires source, and that’s for a couple of reasons.
    Namely, I’m a huge open source advocate and firmly believe that code is not what makes a game great, but the gameplay and concepts behind it. However code provides a large barrier for just about everyone entering into the indie game dev area. That’s what’s great about this event, is that it generates so much source code for people to learn from and learn basics, so they can start implementing their ideas into games.

    Secondly, something I’m surprised you didn’t even touch on in this article, is that source code helps makes things more secure. I question the security behind this competition and as it grows I feel as if it won’t be safe to freely download and rate games because I’ll be worried that an app will take my information, implant R.A.T.’s, do drive-bys and all sorts of fun stuff. While requiring source code isn’t fool proof as it still allows people to upload a playable version with different (and harmful) source, it still requires an alternative method for people to review, compile, and play the games in a way that they can be sure is safe.

    I recognize I’m new here and this was my first time entering, but the flaws in security being apparent to me so quickly worry me in that someone could make a more widespread attack with just a little planning.

    • PoV says:

      Hacking aside, only the person that posts a game is able to add/change its downloads.

      And for sure, giving everyone posting capability on the blog is a big hole. We deal often with spambots. So do most forums.

      • HackThePanda says:

        It’s not other people I’m worried about, it’s people uploading games disguised as legitimate entries that might not be half bad but also run secret code in the background such as RAT’s that can take total control of your computer and files without you ever knowing it’s there.

        • PoV says:

          You are right, though a bit paranoid. 😉

          That is okay thought. As much as I hate to say it, it’s yet another reason to encourage Web Only games, which have already become dominant. As if we needed yet another reason to look down on downloadable games.

          Is there much merit in attacking a handful of game developers (many of them new to it)?

          I would hope the desire to make games is stronger than the desire to be a jerk.

        • Hume says:

          Nothing stopping anyone from uploading code that doesn’t match the executable, or that has the “bad parts” stripped out. The source code requirement is in no way a hindrance to a hypothetical malicious submitter.

  3. soy_yuma says:

    I think there’s a point in which reading other people code (even if it’s not a good example of proper coding) is helpful or even essential.

    First time I participated on a Ludum Dare compo was because I literally studied other people code for weeks. Before that I wasn’t confident that my short experience in programming was enough. After reading a couple of games I felt that I could imitate (not copy) those ideas or patterns.

  4. SiENcE says:

    Source code itself has no real value. You can compare it to open source.

    The aim is to learn from it and while writing the code.

    Most non-programmers always see sourcecode as an valuable item, but the real value is the programmer behind it!

    • mwtb says:

      Ech… Saying that source code has no real value but the programmer does makes no sense. The code is the direct product of consuming the programmer’s finite time employing their learned skill. It’s as silly to say that source has no value as it is to say that a table made by a carpenter has no value, a painting by an artist, a loaf of bread made by a baker or a song by a musician.

      It’s certainly possible for someone to over-value their source (just as they can over-value visual art, or music or a pot of jam) but “you should just give it away because _I_ don’t see it as valuable” isn’t a persuasive argument.

  5. sorceress says:

    Reasoning that source code is useful to enforce rules:
    3. It lets us verify that somebody didn’t cheat (**)
    4. It keeps people honest
    5. It can solve disputes (**)

    I’ve never really understood this. Including source code doesn’t prove in any way that I worked solo. It doesn’t prove in any way that I made my game in 48 hours. It doesn’t prove in any way that I made my game during LD weekend. The only thing it proves is that I have the source code for the game I submitted.

    Arguments about trojans disguised as games don’t work either, since the source code may omit the trojan elements that a compiled exe has.

    Reasoning that source code it is useful to teach:
    1. It’s a good reference for new developers
    7. I like to look at how people implement things
    8. Source code is one of the best things to learn from
    10. Even if it’s not you, somebody will learn from the code
    11. Ludum Dare is about Learning

    People take part in the competition simply because they want to take part in the competition. They may have no additional desire to teach, and that shouldn’t be forced onto them. Those who want to teach (by including source) are free to do that.

    I think it’s generous enough that a person creates a game that is free to play, without demanding source code from that person as well.

    Three reasons I feel are not valid, and I’ll address each of them in turn:
    2. It encourages community
    I would say the opposite is true. Forcing people to share source code is harmful to community. Allowing people the freedom to choose whether to share source code is what is good for the community. Freedom is good.

    6. Some broken games can be fixed with just a few source tweaks
    “source tweaks” implies compiling modified source code, which implies open source. The rules have always emphasized that ludum dare is ‘source included’ which is not the same as ‘open source’.

    9. Any code created in 48/72 hours wont contain any serious secrets
    Maybe, maybe not. A chef can create an exquisite meal in under 48 hours, using a secret family recipe, which they may not want to make public. Similarly, a person’s code may be a product of accumulated wisdom and experience, which makes it into something refined and potentially valuable. Any skilled professional or craftsperson will develop refined techniques and methods that they may not want to share with all and sundry.

    Overall, my feelings are that source code should be encouraged, but is ultimately optional.

    • HackThePanda says:

      The “trojan” argument is perfectly valid as the source code allows you another method to compile and try out the game without worrying about malicious software.

      Source code should be enforced for safety reasons and to promote the open-oriented spirit of this competition.

      • sorceress says:

        It would be valid if the code were “open sourced”. But as the rules stand, this is not a requirement. My argument holds.

        • HackThePanda says:

          Not quite sure what you mean by that.. at all

          • marudziik says:

            If someone uses a proprietary engine, you will not compile anything, unless you also bought the same engine, so your trojan argument isn’t valid at all. Also, “source included” license doesn’t necessarily give you any rights to compile the source itself. I think that would be the case of it not being “open source”, that sorceress is talking about.

            I’m not sure what to think, myself. I actually almost completely agree with sorceress, but I also LIKE to browse through peoples’ code. Mostly it’s a mess, but I did see some great lines here and there. Some of the winning games have great and efficient architecture, and sometimes I just want to see how someone did some effect or something like that.

            I think that the educational part of LD is something that should be encouraged, but I’m not sure about enforcing the FULL code inclusion. I’d say that code without assets would be just as fine.

            • HackThePanda says:

              Rights to compile it? If you’re giving out source code I don’t see how your rights are going to stop me from compiling it for my safety

              • marudziik says:

                I’m not a lawyer, but I’d think this might be similar to what you get when you buy any proprietary software: the license may forbid you to decompile it. In this sense giving out the source doesn’t necessarily mean that the software is “open source”, as in “under GNU/GPL license”. For example, someone may allow you to look into the source, but at the same time (s)he may disallow you to compile it. Welcome to licensing hell.

                And the safety argument really isn’t valid, since from what I understand, even now it’s not necessary to provide all that is needed to compile the source, just the code. It’s silly to expect people to also provide instructions for compilation, or to make them give out all their other assets, just because you feel paranoid about running their software.

                Run it on a virtual machine if you’re afraid that it may contain malware. Simple as that.

      • Hume says:

        Again, you don’t know that the source provided matches the executable provided. These aren’t signed code packages.

        The only way source is “safe” is if you only run entries you rebuild yourself. That isn’t feasible if you want to rate a lot of entries — getting all the build environments up and running would take longer than the competition itself, and using a weird build environment (“built with Haskell!”) would cause community fragmentation. Only the people who can build X will rate X. We have this already with operating systems and people who demand browser-only games, and it’s bad enough.

        I don’t say your whole argument is invalid, but safety is a red herring.

    • Kroltan says:

      I would disagree on your opinion about #2. The Jam exists for that. There is choice. If you want private source, go compete the Jam.

      • mwtb says:

        It’s an option, but the source requirement isn’t the only difference between the main competition and the Jam.

      • sorceress says:

        That’s not a choice between “competition with code” and “competition without code”.
        It’s a choice between “competition” and “jam”. And the jam may not be appealing. Quoting from my other post…

        There’s a reason why most people choose to enter the compo, and not the jam. And I think it’s not the time limit that’s the big issue, but the challenge of having to make everything for oneself.

        The Jam operates on different rules, by allowing teams, 50% more time, and permits use of pre-existing material. So it is less of a challenge, demanding less skill and creativity. A Compo person may want to employ their skills, but if pushed into the Jam, may feel that they cannot fairly compete with others who use a ton of polished pre-existing material.

  6. gameXcore says:

    My opinion on this is that source code should be required, if you don’t like it then simply don’t enter.

    Lets all be honest, you are not the best programmer on the planet, and what you come up with in these 48 hours is not going to be game-changing, if you have a secret method of doing something that will blow peoples minds, then don’t put it in your game, if you do use it and it really is that good then someone will take a look at what you achieved and work-backwards to recreate it.

  7. HeroesGrave says:

    Fear of stolen code is stupidity.
    There is not a very high chance that anything you made is ‘special’.
    If you want, publish it as an engine (as opposed to basecode) and then the source will be a tiny bit safer.

    If you don’t want people to steal your code, DON’T ENTER THE COMPO!
    Seriously people, you think game developers should be good at finding their way around problems.

    Then, imagine source is NOT included. All it takes is someone with a decompiler and your source is available anyway.

    If you want to keep your source private, you may as well leave the internet alone or stop being selfish. People have the right to gain knowledge.

    The best methods for everything, are to be known by everyone. That is the only way for technology to advance.

  8. SunnyCode says:

    I think that asking for the source code can encourage people to code better and to coment more, because they will be more conscious that people will read their code and therefore it will make people participating on the ludum dare less messy and better coders

    • gameXcore says:

      I doubt it, there are a few guys I work with who take part here, and if they see this comment I;m sure they will pipe up and tell you that I massive OCD and I’m no doubt bit of a pain in the ass to colleagues when it comes to code layout and commenting etc.

      However 48 hours is 48 hours, 200 lines of comments = 200 lines less code = 200 lines of less polish :p

  9. Maybe the judging could have a checkbox for if you compiled the source, and show a tally of how many people compiled it. This way the community could help check that the source is valid.

  10. caranha says:

    I think there is one thing that a lot of people are missing:

    There is no way to verify that the source currently submited is equivalent to the binary published. Even if we assume that there is enough manpower to try and compile all the submitted source and test the resulting binary, there are still many ways to “hide” whatever you may want to hide from the submitted source code.

    That said, I’m 100% behind the compo requirement of publishing source code.

    1- As a CS teacher, I have used source code available in LD in the classroom before. I think it is amazing that we can have a source code library of varying complexity and varying degrees of “skill” to use as examples of good code, bad code, beginner’s code, expert’s code, simple code, complex code. Ludum dare for me is a learning experience, and the availability of source is a good part of it.

    2- As a open source enthusiast, I think it is great that we have a place where sharing the source code is encouraged. Too many people think that “Hide everything you do, don’t share anything unless you are benefiting from it” is the standard paradigm, and I think it is refreshing to have somewhere where this view is challenged. In this way, I do think that it “builds community”.

    3- As a game enthusiast, I think that the only way we can preserve games for the future, is by keeping the source open. If someone 20 years from now wanted to reproduce the top winners of LD for any sort of reason, having the source code open would help immensely any porting necessary.

    Also, regarding the “engines”, I think it is kinda obvious that “source code” means the code you made for the LD. I think anyone that expects the source code of Unity or Game Maker is being unreasonable. As a “from scratch” developer, I don’t see anything unfair in that (at least not any more unfair that using a game engine is fair game, but using graphic templates isn’t 😛 but that is another issue altogether)

    • HackThePanda says:

      I agree with what you’re saying about engines, it seems easy enough to upload your project, scripts, whatever it may be you created in the engine for LD.

      I also agree with your stance on learning, there are many different types of coding to benefit from here.

    • Codexus says:

      #1 is a scary thought, in a LD when the deadline is approaching at a frightening pace, how fast something can be coded by copy/pasting something is the #1 priority above everything else. Rename that variable so it matches what it actually does now? Don’t bother the game ships in 10 minutes! 😀

    • mwtb says:

      I think you’re missing the point regarding the fairness to “from scratch” devs. The point is that if you’re a Unity/FlashPunk/GameMaker/Flixel/Whatever user you only have to share the LD game code. If you happen to work with your own engine or libraries then you currently have to share that too. The result is that “from scratch” devs are required to open work that sits way outside the “whatever you write in 48hrs can’t be a big deal” argument.

    • sorceress says:

      1- As a CS teacher, I have used source code available in LD in the classroom before. I think it is amazing that we can have a source code library of varying complexity and varying degrees of “skill” to use as examples of good code, bad code, beginner’s code, expert’s code, simple code, complex code.

      I don’t dispute the usefulness of it, but source code availability is not a black and white thing.

      Even if source code inclusion becomes optional, there will still be plenty of contestants who choose to include it: Plenty of examples of good/bad code. Plenty of examples of simple/complex code. Even if as low as 10% of people choose to include source, you’ll still have a mountain of 400+ code examples per year.

  11. Another thing that needs to be addressed, I think, is how much of extra bells and whistles that engine users can actually use.

    Unity comes with a crap-ton of stuff. Skyboxes, character controllers, tons of camera and water effects, hell even a 150 animation library for use with Mechanim, and with Pro licenses being offered to competitors this stuff is widely available.

    Should it matter if someone uses these things? I was thinking of adding the included “god rays” filter to the end my current entry, but was worried I’d pull a DQ for using it.

    Is there any official ruling on that kind of stuff?

  12. Madball says:

    I don’t think people must release source code, but I’d encourage them to.

    As for myself, I doubt somebody in LD uses the same engine as me. I always include the source code, all you have to right-click and choose “Copy Source Code”. However that’s a code for the engine only, and I can’t go beyond and share the flash source code! Now let’s assume there are much more such engines. If you would like to check their source code, you will have to use all these engines to open it!

    I use this engine for a while, and I think for more than a year I always release the source code for any design I make. I don’t think there is anything scary. Even if somebody steals my code, I don’t worry. But, as was said, the code might be a secret. If you think like that, you don’t have to include the source code and or enter the jam. Why? What is compo and what is jam?
    Compo: a hardcore challenge. You have 2 days, you have to create everything by yourself, blah blah blah.
    Jam: an easycore challenge. You have 3 days, you don’t have to create everything by yourself, blah blah blah.
    How can you call including the source code hardcore and not including it easycore? The main difference is that the jam has more relaxed rules. The source code doesn’t matter.

    About the cheating: many people make timelapses. It’s much more effective means of security than the source code. Some people stream the game making process, that’s even more secure. I think that’ll be unfare if somebody will get a better result by cheating. But I think almost all of the active jammers won’t do that even if they know that they’ll succeed just because of the spirit of challenge.

    I never looked at a source code, mainly because I have very little compilers. And I think many games use custom libraries, resources, etc, so checking the source code may be extremely difficult, as well as publishing. Including the source code isn’t included in the challenge, so the people shouldn’t be stressed by it. If they want, I think they can still enter the compo, because compo games and jam games are different.

    I have an idea of creating 2 game sections: with source and without source. I doubt it makes sense, but if you are eager to solve problems (there are too little problems to solve), you do like that.

    (Oh, and the engine I use guarantees that the source code is exactly the same as the one used in the game)

  13. davidwparker says:

    I’m a day late and a dollar short to chime in (didn’t see the Tweet(s) about it), but here’s my $0.03. (Sorry if I’m repeating what others above already said).

    I always, always, always learn from others’ source. In general, I find 1 or 2 (TOTAL) games that I really liked and look at the source. For example, this time around I’m really interested in ix’s game “Rainbow” http://www.ludumdare.com/compo/ludum-dare-25/?action=preview&uid=18837 which I thought was beautiful. So sometime over the next couple of weeks, I’m going to really look into how he made it. It would be nice to look into other game’s code as well, but I find I just don’t have time to look at more than 1 or 2.

    As for requiring it, I can understand people’s concerns about proprietary-ness. Which, to me, is why this competition is great in that there’s no *real* incentive to cheat. Why cheat? You don’t really get anything great out of it by cheating (no money), so there’s no value there. Maybe prestige? I don’t know… but I think I would allow it either way…

    So long as there’s still awesome people who submit awesome games with their source so I can learn from it :)

Leave a Reply

You must be logged in to post a comment.

[cache: storing page]