7 ms·

Halo was written with a Lisp dialect called blamscript (2014)

119 points by kuwze 8y ago

Sharlin 8y ago
Nb. "Written" as in screenwriting, not "written" as in implementing the game engine itself.
- Insanity 8y ago
  Indeed, I was mislead by the title at first!
- deleted 8y ago
  [deleted]
- yosefzeev 8y ago
  Did you find an example of this in that link somewhere?
- msbarnett 8y ago
  The game engine, no. But the game logic, the code that makes the game engine do the things that make what it's doing Halo as opposed to some-other-game-on-that-engine, is written in blamscript. "Screenwriting" to me would sort-of imply that this was all just for human consumption during planning, and later implemented in something else.
  - Sharlin 8y ago
    I first meant to use its synonym, "scriptwriting", but that one of course has a somewhat diverged meaning in the computer world. But actually in interactive fiction the meanings beautifully converge again.
- xkapastel 8y ago
  Screenwriting is not a term people use for programming languages, I think you're looking for "scripting".
Haga 8y ago
I cant help but think that a lualisp merge would be the ideal script addition for all most any engine.
- adrianm 8y ago
  Have you seen Fennel? https://fennel-lang.org/ https://fennel-lang.org/
- sifoobar 8y ago
  I started writing my own embedded scripting language [0], based on Forth and Lisp rather than Lua. Besides being easy to embed, there's not much in Lua worth keeping if you ask me. [0] https://gitlab.com/sifoo/snigl https://gitlab.com/sifoo/snigl
ryanmercer 8y ago
Meanwhile, Halo 2600 was written in Atari BASIC (probably) https://atariage.com/store/index.php?l=product_detail&p=998 https://atariage.com/store/index.php?l=product_detail&p=998
- jtr_47 8y ago
  I wonder what an AtariLisp would look like ;p
  - aidenn0 8y ago
    Something like this? https://www.youtube.com/watch?v=nY_hcazo86A https://www.youtube.com/watch?v=nY_hcazo86A
    - protomyth 8y ago
      The Atari 8-bit machines supported a lot of language, even some I've never seen since like Action! https://en.wikipedia.org/wiki/Action!_(programming_language) https://en.wikipedia.org/wiki/Action!_(programming_language)
- reidrac 8y ago
  The 2600 didn't have BASIC. Not viable with only 128 bytes of RAM. It was written in assembler: http://atariage.com/forums/topic/185693-halo-2600-source/ http://atariage.com/forums/topic/185693-halo-2600-source/
  - opencl 8y ago
    The 2600 actually did have a BASIC interpreter cartridge available. It was both an incredible engineering feat (interpreter and IDE in 4K ROM and 64 bytes of RAM) and completely useless (because your program only had the other 64 bytes of RAM).
    - reidrac 8y ago
      Fair enough, looks like viability (or being "totally useless") didn't stop people back then!
vernie 8y ago
I believe that Naughty Dog also scripts game logic in their own Lisp dialect.
- hcarvalhoalves 8y ago
  https://en.wikipedia.org/wiki/Game_Oriented_Assembly_Lisp https://en.wikipedia.org/wiki/Game_Oriented_Assembly_Lisp
- justbaker 8y ago
  Article on GOAL/creating Crash Bandicoot by creator, Andy Gavin: https://all-things-andy-gavin.com/2011/02/02/making-crash-bandicoot-part-1/ https://all-things-andy-gavin.com/2011/02/02/making-crash-ba... Certainly my favorite Lisp game.
- aidenn0 8y ago
  IIRC, GOOL was a lisp dialect used for scripting Crash Bandicoot; later ND games were written in GOAL (i.e. not just scripting, but the majority of the game was written in lisp).
- steinuil 8y ago
  Other than the games they wrote entirely in GOAL, all of their PS3+ games use a series of lispy DSLs implemented in Racket that get compiled to C and C++ for defining data to be loaded in the game and dependencies between these data, light scripting, dialogues, stuff like that. There's a talk by one of the engine devs at RacketCon from a few years ago on youtube about how they use these DSLs and how they came to be: https://youtube.com/watch?v=oSmqbnhHp1c https://youtube.com/watch?v=oSmqbnhHp1c
blattimwind 8y ago
Meanwhile, Half-Life/GoldSrc/Source scripting means placing "entities" in the world space and connecting them. Like a very messy form of visual/block-based programming. On many maps with a lot of scripts there are separate, inaccessible rooms where the mapper stashed all the entities, because placing them where their triggers / effects happen would make editing the level geometry quite difficult.
jayd16 8y ago
>Any sufficiently complicated program contains an ad-hoc, informally-specified, bug-ridden, slow implementation of half of Common Lisp I find this quote especially true in games.
- yellowapple 8y ago
  This is also especially true, per Morris' corollary, of Common Lisp.
- mbrodersen 8y ago
  >Any sufficiently complicated program contains an ad-hoc, informally-specified, bug-ridden, slow implementation of half of Common Lisp I call BS on that one. I have worked on very large scale C++ software (games etc.) and have never seen or needed anything like Common Lisp to get the job done. And I actually know how to program in Common Lisp (and Scheme) and have implemented my own Lisp variations for fun.
  - lispm 8y ago
    > seen or needed anything like Common Lisp That's not the point. It's not half a Common Lisp, but half of (the features) of Common Lisp: code generation/macros, runtime scripting language, loading of code, interactive error handling, a console to interact with the program, dynamic objects, exchanging data in a textual format, a configuration language, etc. etc
grogenaut 8y ago
We had this at another Sony studio I worked at. I asked why. The person who write it said writing the interpeter/compiler for lisp is quite easy. As is understanding the byte code. They did it as an intern project in about 3 months. It wasn't the most friendly language and ended up with many c like additions. At the end of the day it was all about cost to work on and efficiency of using. Many would have been super happy to slap a "real" language in there but they would have spent years putting the real time esque controls they needed on it. Not the normal real time but bound to game engine execution phases which is different. It also needed to very easily work with cpp and the art tree. I doubt any of the fp folks here would have loved the language and would have spent much of their kvetching time on why it wasn't more lispy and therefore more productive. Thing is most of what it needed to do was atomic thread and mutex/semaphore joins, branching parallel green threads and parallel wait conditions and goto. The scripts were all written by non programmers and when slow converted to c++ which was about 20kx faster.
jorvi 8y ago
Don’t most engines offer this by default? I know Unreal Tournament 99 and especially 2004 was very extensible because they offered uScript (very C++ like) which made it easy to make all sorts of mutators and mods. They even had a specific feature for making in-game cutscenes (I thought it was named Kino but apparently not). I don’t have much knowledge of Source but afaik they also offered something similar.
bitwize 8y ago
Recently I learned that the AI for Age of Empires was also written in a Lisp-like dialect. Interesting.
rongenre 8y ago
This seems like a pretty typical pattern: Back when I did games (mid 90's), it was pretty essential to come up with a tight game engine with components that could be driver from a script: That way someone in design/production could focus on making things interesting and fun without needing to mess with a compiler. In our case, we used tcl, but embeddable lisp would have worked too.
t3hz0r 8y ago
The title is misleading. Blamscript is only really used in the interactive consoles of the game and its editing kit, and the scripting of encounters, cinematics, and triggers in the campaign[1]. Modders also use it in custom multiplayer maps for things like doors. Since Halo PC's netcode doesn't synchronize the state of such scenery to players, some map makers came up with the clever idea of hidden "biped crusher" rooms which repeatedly dropped vehicles on NPCs depending on the state of doors. Their respawns _were_ synchronized across the network, so this system could be used to trigger doors opening/closing on clients. [1]: https://github.com/Dwood15/HaloScripts https://github.com/Dwood15/HaloScripts

119 points by kuwze 8y ago

Sharlin 8y ago

Nb. "Written" as in screenwriting, not "written" as in implementing the game engine itself.

Insanity 8y ago
Indeed, I was mislead by the title at first!
deleted 8y ago
[deleted]
yosefzeev 8y ago
Did you find an example of this in that link somewhere?
msbarnett 8y ago
The game engine, no. But the game logic, the code that makes the game engine do the things that make what it's doing Halo as opposed to some-other-game-on-that-engine, is written in blamscript. "Screenwriting" to me would sort-of imply that this was all just for human consumption during planning, and later implemented in something else.
- Sharlin 8y ago
  I first meant to use its synonym, "scriptwriting", but that one of course has a somewhat diverged meaning in the computer world. But actually in interactive fiction the meanings beautifully converge again.
xkapastel 8y ago
Screenwriting is not a term people use for programming languages, I think you're looking for "scripting".

Haga 8y ago

I cant help but think that a lualisp merge would be the ideal script addition for all most any engine.

adrianm 8y ago
Have you seen Fennel? https://fennel-lang.org/ https://fennel-lang.org/
sifoobar 8y ago
I started writing my own embedded scripting language [0], based on Forth and Lisp rather than Lua. Besides being easy to embed, there's not much in Lua worth keeping if you ask me. [0] https://gitlab.com/sifoo/snigl https://gitlab.com/sifoo/snigl

ryanmercer 8y ago

Meanwhile, Halo 2600 was written in Atari BASIC (probably) https://atariage.com/store/index.php?l=product_detail&p=998 https://atariage.com/store/index.php?l=product_detail&p=998

jtr_47 8y ago
I wonder what an AtariLisp would look like ;p
- aidenn0 8y ago
  Something like this? https://www.youtube.com/watch?v=nY_hcazo86A https://www.youtube.com/watch?v=nY_hcazo86A
  - protomyth 8y ago
    The Atari 8-bit machines supported a lot of language, even some I've never seen since like Action! https://en.wikipedia.org/wiki/Action!_(programming_language) https://en.wikipedia.org/wiki/Action!_(programming_language)
reidrac 8y ago
The 2600 didn't have BASIC. Not viable with only 128 bytes of RAM. It was written in assembler: http://atariage.com/forums/topic/185693-halo-2600-source/ http://atariage.com/forums/topic/185693-halo-2600-source/
- opencl 8y ago
  The 2600 actually did have a BASIC interpreter cartridge available. It was both an incredible engineering feat (interpreter and IDE in 4K ROM and 64 bytes of RAM) and completely useless (because your program only had the other 64 bytes of RAM).
  - reidrac 8y ago
    Fair enough, looks like viability (or being "totally useless") didn't stop people back then!

vernie 8y ago

I believe that Naughty Dog also scripts game logic in their own Lisp dialect.

hcarvalhoalves 8y ago
https://en.wikipedia.org/wiki/Game_Oriented_Assembly_Lisp https://en.wikipedia.org/wiki/Game_Oriented_Assembly_Lisp
justbaker 8y ago
Article on GOAL/creating Crash Bandicoot by creator, Andy Gavin: https://all-things-andy-gavin.com/2011/02/02/making-crash-bandicoot-part-1/ https://all-things-andy-gavin.com/2011/02/02/making-crash-ba... Certainly my favorite Lisp game.
aidenn0 8y ago
IIRC, GOOL was a lisp dialect used for scripting Crash Bandicoot; later ND games were written in GOAL (i.e. not just scripting, but the majority of the game was written in lisp).
steinuil 8y ago
Other than the games they wrote entirely in GOAL, all of their PS3+ games use a series of lispy DSLs implemented in Racket that get compiled to C and C++ for defining data to be loaded in the game and dependencies between these data, light scripting, dialogues, stuff like that. There's a talk by one of the engine devs at RacketCon from a few years ago on youtube about how they use these DSLs and how they came to be: https://youtube.com/watch?v=oSmqbnhHp1c https://youtube.com/watch?v=oSmqbnhHp1c

blattimwind 8y ago

Meanwhile, Half-Life/GoldSrc/Source scripting means placing "entities" in the world space and connecting them. Like a very messy form of visual/block-based programming. On many maps with a lot of scripts there are separate, inaccessible rooms where the mapper stashed all the entities, because placing them where their triggers / effects happen would make editing the level geometry quite difficult.

jayd16 8y ago

>Any sufficiently complicated program contains an ad-hoc, informally-specified, bug-ridden, slow implementation of half of Common Lisp I find this quote especially true in games.

yellowapple 8y ago
This is also especially true, per Morris' corollary, of Common Lisp.
mbrodersen 8y ago
>Any sufficiently complicated program contains an ad-hoc, informally-specified, bug-ridden, slow implementation of half of Common Lisp I call BS on that one. I have worked on very large scale C++ software (games etc.) and have never seen or needed anything like Common Lisp to get the job done. And I actually know how to program in Common Lisp (and Scheme) and have implemented my own Lisp variations for fun.
- lispm 8y ago
  > seen or needed anything like Common Lisp That's not the point. It's not half a Common Lisp, but half of (the features) of Common Lisp: code generation/macros, runtime scripting language, loading of code, interactive error handling, a console to interact with the program, dynamic objects, exchanging data in a textual format, a configuration language, etc. etc

grogenaut 8y ago

We had this at another Sony studio I worked at. I asked why. The person who write it said writing the interpeter/compiler for lisp is quite easy. As is understanding the byte code. They did it as an intern project in about 3 months. It wasn't the most friendly language and ended up with many c like additions. At the end of the day it was all about cost to work on and efficiency of using. Many would have been super happy to slap a "real" language in there but they would have spent years putting the real time esque controls they needed on it. Not the normal real time but bound to game engine execution phases which is different. It also needed to very easily work with cpp and the art tree. I doubt any of the fp folks here would have loved the language and would have spent much of their kvetching time on why it wasn't more lispy and therefore more productive. Thing is most of what it needed to do was atomic thread and mutex/semaphore joins, branching parallel green threads and parallel wait conditions and goto. The scripts were all written by non programmers and when slow converted to c++ which was about 20kx faster.

jorvi 8y ago

Don’t most engines offer this by default? I know Unreal Tournament 99 and especially 2004 was very extensible because they offered uScript (very C++ like) which made it easy to make all sorts of mutators and mods. They even had a specific feature for making in-game cutscenes (I thought it was named Kino but apparently not). I don’t have much knowledge of Source but afaik they also offered something similar.

bitwize 8y ago

Recently I learned that the AI for Age of Empires was also written in a Lisp-like dialect. Interesting.

rongenre 8y ago

This seems like a pretty typical pattern: Back when I did games (mid 90's), it was pretty essential to come up with a tight game engine with components that could be driver from a script: That way someone in design/production could focus on making things interesting and fun without needing to mess with a compiler. In our case, we used tcl, but embeddable lisp would have worked too.

t3hz0r 8y ago

The title is misleading. Blamscript is only really used in the interactive consoles of the game and its editing kit, and the scripting of encounters, cinematics, and triggers in the campaign[1]. Modders also use it in custom multiplayer maps for things like doors. Since Halo PC's netcode doesn't synchronize the state of such scenery to players, some map makers came up with the clever idea of hidden "biped crusher" rooms which repeatedly dropped vehicles on NPCs depending on the state of doors. Their respawns _were_ synchronized across the network, so this system could be used to trigger doors opening/closing on clients. [1]: https://github.com/Dwood15/HaloScripts https://github.com/Dwood15/HaloScripts