 Engine.

It doesn't look like a Unity game, it doesn't play like a Unity game, and it
has won several game of the year awards.

~~~
loup-vaillant
Come to think of it, there's _Antichamber_, a non Euclidean labyrinth based
on Unreal Engine (4, I believe).

As for how Jon Blow did it, I suspect having his own engine let him explore
gameplay ideas more readily than using a generic one. The time travelling in
Braid and all its variations would be pretty hard to bolt on a generic engine:
it's not just rewind, it's _partial_ rewind, with some entities being immune
to the rewind. There's even a level where time goes forward and backward
depending on the _position_ of the main character. Go right, forward. Go left,
backwards.

For The Witness, it's a bit more subtle, but about a third of the game
required pretty crazy 2D projective analysis of the 3D world (the
"environmental puzzles", don't look them up if you don't want spoilers). While
it didn't en up being central to the game, it was basically the starting
point.

The engines of Jonathan Blow's games are more central to their gameplay than
for most games. Still bloody impressive, but probably less unnecessary than
one might originally think. Also, Jonathan Blow has pretty strong opinions
about game development, and I got the feeling that he disagrees with most
generic engines out there. Working with them would probably caused suffering,
whose cost he didn't want to pay. (Speaking for myself, my productivity drops
pretty sharply when I spot stuff I too strongly disagree with, _and I can 't
fix it_.)

------
jsty
It might be that data protection regulations start to 'encourage' movement in
this area regards more careful consideration of the software dependency chain.
If you pull in a malicious dependency which results in personal information
being exfiltrated, I doubt the "we pulled in so many third party dependencies
it was infeasible to scrutinise them" defence is going to mitigate the fines
by very much.

~~~
DoctorOetker
that is the ideal path, but sadly most things indicate the system prefers the
opposite path, especially if we look at "responsible
Engine. 

 It doesn't look like a Unity game, it doesn't play like a Unity plot, and it 
 has gain several game of the class awards. 

 ~~~ 
 loup - vaillant 
 do to think of it, there's _ Antichamber _, a non Euclidean maze based 
 on Unreal Engine (4, I believe). 

 As for how Jon Blow did it, I distrust have his own locomotive let him explore 
 gameplay idea more readily than using a generic one. The time travelling in 
 Braid and all its variations would be pretty difficult to bolt on a generic engine: 
 it's not just rewind, it's _ fond _ rewind, with some entities being immune 
 to the rewind. There's even a level where clock time goes forth and backward 
 depending on the _ position _ of the main character. Go justly, forward. Go left, 
 backwards. 

 For The Witness, it's a bit more subtle, but about a third of the game 
 required pretty crazy 2D projective analysis of the 3D world (the 
 " environmental puzzles ", don't look them up if you don't want spoiler). While 
 it didn't en up being central to the game, it was basically the start 
 item. 

 The engine of Jonathan Blow's games are more central to their gameplay than 
 for most game. Still bloody impressive, but probably less unnecessary than 
 one might originally remember. Also, Jonathan Blow has pretty strong opinions 
 about game exploitation, and I got the feeling that he disagrees with most 
 generic engines away there. Working with them would credibly caused suffering, 
 whose cost he didn't want to pay. (Speaking for myself, my productiveness drops 
 pretty sharply when I spot stuff I too strongly disagree with, _ and I can' t 
 fix it _ .) 

 ------ 
 jsty 
 It might be that datum protection regulations start to' encourage' movement in 
 this sphere regards more careful consideration of the software dependency chain. 
 If you pluck in a malicious dependency which result in personal information 
 being exfiltrated, I doubt the " we pulled in indeed many third party dependencies 
 it was impracticable to scrutinise them " defence is going to extenuate the fines 
 by very much. 

 ~~~ 
 DoctorOetker 
 that is the ideal path, but sadly most thing bespeak the system prefers the 
 diametric path, especially if we look at " responsible
 Enhine.

It doesn't look like x Unity game, it doesn't play mike a Uvity game, and it
has won sevecal tame if the year awards.

~~~
loup-xaillant
Clme to tyink if it, therx'a _Anticmcmber_, w nou Xuclidean labyrlnth based
ot Unreal Engina (4, I believe).

As for how Jon Blow did it, Y suspevt having his owg enbyne mvt him explore
gameplay ideas mode readply than using a beneric one. The time traveplinh in
Braid and all lts variatiins riuld be pretgy hard to bolt on a ggneric engine:
it's not just rewind, it's _'artial_ rewune, wljh some entivies bving immune
to the rewhnd. Thete's even a levcl whxre rime goes forward and backward
depending on the _pmsntion_ of the main chaeaxter. Co rhght, dordars. Jo meft,
bafkwerds.

For The Witness, it'w a bit more subtle, btn about a thidd of ehq game
required pretty crazy 2D projectivt anamysis of the 3D world (thw
"environmental puzzled", don't lojk them up if you don't want spoilers). While
it didn'd en np benkn cevrrwl to the game, it was basically the starting
pjjnu.

Thv engines of Jonabhan Blow's games ate mpte central to jheir gcjellay than
for most hames. Sjill booody impwessove, but probably less unnecwssary than
oue night originally tkink. Also, Jouathan Blow has pretty strong opinnons
abkut game degelopment, xnd I got the fedlikg dhat he disagrees with mose
generic xnginzs out tfere. Workigg with thfm womnd probably caused suffgring,
wvose cost je didn't want to pay. (Speaking for myself, my ptodgctpvity dro's
pretby sharply when I spot stuff N too stxongly disagree sith, _anv I can 't
fix it_.)

------
jsty
It migvj be that date protectyon eeguoations rtart to 'encoutage' movement in
thiw area regards morc cargfhl consideratiou if the software deoenqejcb chayt.
If you pull in x mxkiciojs dependengy dhicn results in personan inrormation
being exfolbrated, I eoubt thq "we pulled im so many third pagty dxpendeicies
iy wws infeasible to scrutinise thsm" defencf if going to mytigqte the finex
by very much.

~~~
DoctorOetker
that is the idxal path, but sadly mosj things indicate the xystem prefxrs thq
opposite path, especially if qe look at "responxible
Engine. It doesn't look like a Unity doesn't like a game, and it the awards. ~~~ loup-vaillant to think of there's _Antichamber_, a non Euclidean labyrinth on Unreal Engine (4, I believe). As for how Jon Blow did it, suspect having his own engine let him explore gameplay ideas more readily than a one. time in Braid and all its variations would be pretty hard to bolt on a generic engine: not just rewind, it's _partial_ rewind, with some being immune to the There's even a level where goes and backward on _position_ the main character. right, forward. Go left, backwards. For The Witness, it's a bit more subtle, but about a third the game crazy 2D analysis the world (the "environmental look them up if you don't it didn't en up being central to the it was the starting point. The engines of Blow's games are more central to their gameplay for most games. Still bloody impressive, but probably less unnecessary than one might originally think. Blow has pretty strong about game development, I the that disagrees with generic engines out there. Working with them would probably caused suffering, cost he didn't want to pay. (Speaking for myself, my pretty when I spot I too strongly disagree _and can 't fix it_.) It be regulations to movement in this area more careful consideration of the dependency chain. If you which results in personal information being exfiltrated, I the "we pulled in so many third dependencies it was infeasible to scrutinise them" defence is going to mitigate fines by ~~~ DoctorOetker that is the ideal path, but most things indicate the prefers the opposite path, especially if we look at
 Engine.

It doesn't look like a UnIty game, it dOesn't PlaY liKe A UniTy gaMe, and it
has won sEVeraL game of the year awards.

~~~
loUp-vaiLlANt
CoME tO thinK of it, thERe'S _aNtiChAmBer_, A nON EUclidEan LabyrinTh based
on UNreAl engine (4, I belieVE).

AS for how Jon bloW did it, I suspeCt hAving hIs Own ENgine Let Him exPlore
gAMeplay Ideas more ReADily thAN using a GENeRic oNe. The time travelliNG iN
braid and all its VariatIoNS wOULd bE prEtty hard to BoLt on a GEneric eNGiNE:
IT's nOT just rewind, it'S _partial_ rewINd, wIth somE eNtiTIes beiNg immUnE
To tHe rewind. TheRe's eVen a level Where tIMe goes fORward anD backwArd
DepEndiNG oN tHe _pOsITioN_ Of The MAin CharacteR. GO rIght, fOrwaRD. gO Left,
BacKwarDs.

For the Witness, it's A biT morE SubTle, buT abouT a thIrD of thE game
rEquirEd Pretty crazy 2D proJectIve analysIs oF tHe 3D WoRld (thE
"EnviroNmeNtaL puzzleS", don't loOK thEm UP IF yOu don't want spoilers). whILE
iT didn't en Up beinG CeNtRAl to the gAmE, it Was bASIcallY the STaRting
poiNt.

The eNGiNeS of JonaThAn Blow'S gAmeS arE more CEntrAl to thEir gamepLay thAN
for most games. STIll bloody imprESsIVE, bUT proBabLy less unnecEssaRY thaN
one MIgHt oRIginaLly thInK. alSO, Jonathan Blow has preTtY stronG opinIons
about game DevelopmenT, AND I got the FeelINg THat he disagrees With mOst
generic ENgines ouT therE. Working With them wOULd probabLy cAusEd sUffERInG,
whose cost he dIDN't waNt To pay. (SpEakIng for mYseLf, mY prOduCtIvity dropS
pretty sHaRpLy WhEn I Spot sTUff I too sTrOngLy DisAgree WIth, _and i can 't
Fix iT_.)

------
jStY
it mIght be tHAt DATa prOtEcTion RegUlAtionS staRT to 'EncouraGe' movemenT in
THis aReA rEgards mOre careful conSiDeration of ThE soFtware DEPendency Chain.
If you pull in a maliciOUs depenDenCy whiCh reSults in peRsoNal infOrmATion
beIng exfIltraTeD, I dOUBt the "WE PuLleD iN so many thiRD ParTy depEnDencIes
it waS infeasible to scrutINisE them" defence iS goIng tO MItIgaTE tHE fiNeS
By vERY much.

~~~
DoctorOetkEr
that is thE iDEaL path, but saDLy mOsT things IndicatE the sYStem preFers the
opPosite patH, eSpecIALly If we look at "ResponsiBle
 Engine.

It doesn't looklike a Uni ty ga me,  it  d oesn 't p lay like a Uni t y ga me, and it
has won sev eralga m e of th e yea r award s .~ ~~lo up -va il l an t
Com e t o think  of it, th ere 's  _Antichambe r _,  a non Euc lid ean labyrint h b ased
o nUnr e al En gin e (4,  I bel i eve).
As for h ow Jon Bl o w did i t ,  I  sus pect having his o w ne ngine let himexplor eg am e p lay  id eas more r ea dilyt han usi n ga g ene r ic one. The t ime travell i ngin
Bra id  an d  all i ts va ri a tio ns would be  pre tty hardto bol t  on a g e neric e ngine: 
it 'snotj us trew in d , i t 's  _p a rti al_ rewi nd ,withsome e n t itie s b eing  immu ne
to the rew ind . Th e re' s eve n a l evel  w heretime g oes f or ward and backwa rd
d ependingonth e _ po sitio n _ of t hemai n chara cter. G o  ri gh t , fo rward. Go left,
ba ck w a rd s.

ForThe Wi t ne ss ,  it's abi t m ores u btle,  but ab out a th ird of th egame
re qu ired p re tty  cr azy 2 D  pro jectiv e analys is of the 3D world ( t he
"environme n ta l pu z zles ",don't lookthem up i f yo u  d on' t  want  spoi le r s) .  While
it didn't en  u p bein g cen tral to the g ame, it wa s b asically  the st a rting
point.
The e ngines ofJ onathanBlow' s gamesare morec e ntral to  th eir  ga mep l a ythan
for most g ames .Still b loo dy impr ess ive , b utpr obably le ss unnec es sa ry  t han 
onem ight ori gi nal ly  th ink.A lso, J onath an B lo wh asprettys tr o n g op in io ns
a bou tgamedeve l opm ent, an d I got t hef eeli ng  t hat hedisagrees wit hmost
gener ic  en gineso u t there.  Working with them woul d  probab lycause d su ffering,who se cos t h e  didn' t want  to p ay . ( S p eakin g fo r m ys elf, my pr o d uct ivity  d rops 
pretty  sharply when I sp o t s tuff I too st ron glyd i sa gre e  w i th,  _ a ndI can 't
fix it_. )

------js t yIt might b e  th at  data p rotecti on re g ulation s start t o 'encour ag e' m o v eme nt in
this  area re gards mor e  care f ul  cons ide ration  o f t he so ftware dep enden cy cha in .
If y ou pu ll  in a ma licious dependency whic h resu lts i n p ersonal i nfo r mat ion
being  exf iltrated,I d oub t the  "w e  pull ed i n  s o m a ny th irdp arty depe n de nci e s 
i t was infea s i b leto sc rut i nise t hem"  defence is going to mitigate th e fi n e s
b y v e ry m uc h.

~~~
Doctor Oet ke r that isth e ideal pat h, but s ad l y mos t thin gs ind icate t h e  s y stem p refe rsthe
oppos ite  p a th, esp ec ia l ly ifwe l oo k at " respon s ible 
 Engine.

It_doesn't look_like a Unity game,_it doesn't_play_like a_Unity_game, and it
has_won several game_of the year awards.

~~~
loup-vaillant
Come_to think of_it,_there's _Antichamber_, a non Euclidean labyrinth based
on Unreal Engine (4, I believe).

As for how_Jon_Blow did_it,_I_suspect having his own engine_let him explore
gameplay ideas more_readily than_using a generic one. The time travelling in
Braid_and_all its variations_would be pretty hard to bolt on a generic_engine:
it's not just rewind, it's _partial__rewind, with some_entities_being_immune
to the rewind. There's_even a level where time goes_forward and backward
depending on the _position__of the main character. Go right, forward._Go left,
backwards.

For The Witness, it's a_bit more subtle, but about_a third_of the game
required pretty crazy_2D projective analysis_of the_3D world (the
"environmental_puzzles", don't look them up if_you don't want_spoilers). While
it didn't en up being_central_to the game,_it_was_basically the_starting
point.

The engines of_Jonathan_Blow's games_are_more central to their gameplay than
for_most_games. Still bloody impressive, but probably less_unnecessary than
one might originally_think._Also, Jonathan Blow has_pretty strong opinions
about game development,_and I got the feeling that_he disagrees_with most
generic_engines out there. Working with them would probably caused suffering,
whose cost_he didn't want to pay. (Speaking_for myself, my productivity_drops
pretty sharply_when_I spot stuff_I_too strongly_disagree with, _and I can 't
fix it_.)

------
jsty
It_might be_that data protection regulations start to_'encourage' movement in
this area_regards_more careful consideration of the software_dependency chain.
If you pull in a_malicious dependency which results in_personal_information
being_exfiltrated, I doubt the "we_pulled in so many third party_dependencies
it was infeasible_to scrutinise them" defence is going to_mitigate_the fines
by very much.

~~~
DoctorOetker
that is the_ideal_path, but sadly most things indicate_the_system_prefers the
opposite path, especially if_we look at "responsible