5 ms·

Spatial languages: Writing code in 2D

121 points by BinRoo 2mo ago

zellyn 2mo ago
I find it endlessly fun that one of the best environments for playing with befunge is written for the zmachine.
BinRoo 2mo ago
I ventured out to better read Qiskit code, and came back with this fun idea of 2D expressions
cavoirom 2mo ago
in the same spirit, checkout Orca: https://100r.co/site/orca.html https://100r.co/site/orca.html It is used to compose songs. You can see the demo in the linked page.
- atoav 2mo ago
  It is mentioned at the bottom of the page, but yeah Orca ia pretty good.
shevy-java 2mo ago
Soon we have an IDE that works in 3D. So, not only do you have to look left-right, then top-bottom, but also before, and behind. That's scaling code! You write in 3D now. Or, you stick to oldschool old people. Keep things simple.
- ivanjermakov 2mo ago
  I think humans are pretty good at thinking/operating in a 3D space. It's just that digital interface and programming tooling is not there. Obviously because usually there is no direct translation from domain model to physical 3D shapes. But it can well for those that translate: 3D modelling, spatial reasoning, motion tracking, mechanics, etc.
  - xpct 2mo ago
    I imagine this varies by person, but thinking about a source file is already reminiscent of 2D space navigation, where the X axis is typically gated by conditions. In a similar vein, when I think about functions from different source files, I do hold some type of "depth", or "stacked panels" in my brain. I think this is because I reason about programs being in some state ~= being positioned at a certain function with some context I carry around. I'm sure it's not the only way to think about it, but it's a reasonable abstraction over what computers do. It's how we oriented our debuggers and early IDEs on as well, and carried this over to modern tools. Definitely something I'll be thinking about during the next few days.
    - ivanjermakov 2mo ago
      For real! Good contenders for 3 dimensions: individual expressions, call stack, time.
- Towaway69 2mo ago
  My approach is to start out with a 2D programming environment and once that becomes a general programming environment, to scale that up to 3D and explore how to map 2D to 3D. So first map 1D concepts to 2D and then move on. As a 2D representation, I've been using flow based programming (FBP)[1] and it's incarnation in Node-RED[2]. The trick here is to understand how to use FBP to create more generalistic programs, i.e., to prove it's Turing Complete. I think it would be a mistake to just start out with a 2D approach without also taking all the learnings we have made in 1D, i.e. TDD, OOP, KISS, DRY, Functional, Message Passing, Processes etc, and porting those to a 2D representation. [1]: https://jpaulm.github.io/fbp/ https://jpaulm.github.io/fbp/ [2]: https://nodered.org/ https://nodered.org/
jerf 2mo ago
"All this time we’ve been writing expressions in 1D space, but what happens when we unlock an extra dimension?" Text is a serialization of an n-dimensional work space. "N-dimensional" doesn't have a formal definition I'm aware of but the major characteristic of it is that a new dimension can pop up anywhere. If you feel like you want to double-click on that, you can see my earlier comment here: https://news.ycombinator.com/item?id=35096647 https://news.ycombinator.com/item?id=35096647 A conventional textual language can represent everything mentioned there, whereas 2D layouts struggle almost immediately to represent things that textual layouts represent quite easily. It can still be a useful "see the world differently" exercise, but it's the opposite of "freeing your mind"... it's stepping into a fairly small subset of functionality, albeit an unconventional one, and seeing what you can still manage to do even so. Rather than "unlocking a new dimension" it's actually throwing away n-2 of them. The experience of using this for any period of time would reveal this, as it would be a constant struggle to represent even very simple algorithms in this format. I post this mostly because of the "familiarity breeds contempt" effect that programmers seem to get hit with for text. There is a reason we use text and it's not lack of imagination or being stuck in our ways... it is actually an incredibly rich and powerful format that poses a serious challenge for any alternative to overcome because of the astonishing combination of compactness combined with representational power.
- vitally3643 2mo ago
  A certain subset of programmers apparently just really, really hate this whole messy concept of "thinking about things". Text works and is hard because it's a projection of a mental representation. The whole reason we can work with N-dimensional structures in text is because the dimensionality lives in the programmer's head. There isn't really any other way to represent say a >3 dimensional array other than laboriously flattening it into text and expecting the next guy to rotate the hypercube in his mind. That's neither a good nor bad thing, it's purely a fact of our 3+1 dimensional universe. A shocking number of problems can be best represented in higher dimensions and there's simply no way to encode that information losslessly. Being simple 3D creatures (I'd argue 2D in fact) the only way to do that is by projecting it down into a lower-dimensional space.
  - 2mo ago
dahart 2mo ago
This is cute, and it’s fine and fun to play around, but I don’t know, takes itself way too seriously or something. I apologize for being negative, but blowing my mind? No, not exactly. The attempt at the end to justify isn’t compelling to me and feels pretentious or something; the so-called Sapir-Whorf hypothesis (a misnomer according to the link) is about words and concepts, not about layout. This article fails to consider how to say or to read 2D code, or even think about why text is normally 1D. Language is expressed in one dimension because of time. We don’t speak in 2D, because we can’t, therefore we don’t write in 2D. We do visualize parse trees as trees (2D pictures) all the time, which isn’t mentioned. Also not mentioned are all the massive downsides of trying to write & edit & maintain 2D code, as well as the fact that we have good ways to write 3+ argument functions in 1D. Nitpick - the andFlip function is wasting a whole dimension with unnecessary lines, and also modifying its input argument unnecessarily (yuck!), and it takes 3 arguments as an array for no good reason. Better: andFlip = lambda a,b,c : not c if (a and b) else c Except this is really just a normal 2 argument ternary, it does nothing interesting with a or b individually, it treats them as a unit, so I’d argue this shouldn’t even be a function.
pja 2mo ago
Was this post prompted by this year’s ICFP competition? https://icfpcontest2026.com/ https://icfpcontest2026.com/
levzettelin 2mo ago
This is just silly. The great gift of language is that it allows us to talk about arbitrarily complex things using a stream-like medium. Human speech is fundamentally 1D. The tree like structure of the concepts in language then facilitates the exponential growth in complexity. Or maybe centuries of human progress just went completely in the wrong direction? Unlikely. Nothing wrong with being silly, of course.
intrstng-stff 2mo ago
> Cube is a three-dimensional, visual, statically typed, higher-order logic programming language, designed to be used in a virtual-reality-based programming environment. In this paper, we give an informal overview of the language and describe a prototype implementation. https://marc.najork.org/papers/jvlc1996.pdf https://marc.najork.org/papers/jvlc1996.pdf
- tikimcfee 2mo ago
  I didn't know this paper existed and I'm excited to devour this. I've got my 3D glyph rendering system at glyph3d.dev, and use cases like this help accelerate layout and relationship development immensely. I greatly appreciate your sharing this! Would you happen to have a trove of similar research or papers I could sponge off of you? Or maybe even a few minutes of your time in some chats / emails to discuss how these tools can be brought to a modern runtime?
  - utopiah 2mo ago
    Interesting, I'm relying on Troika (and a-troika-text for AFrame for WebXR) for https://git.benetou.fr/utopiah/text-code-xr-engine https://git.benetou.fr/utopiah/text-code-xr-engine
glouwbug 2mo ago
Anyone here ever use labview?
- rogerdickey 2mo ago
  Yeah. Love it! Used to make games with it, even
robertlagrant 2mo ago
> We don’t really see 3-arity functions written in infix notation much. Would a better example be Python's inline if else construction? x = 3 if thing else 4
DanielVZ 2mo ago
I was recently spending the last few days pondering how I would program in pen and paper if there were no technical restrictions other than having to define the program. I just started note taking by hand and I find it way more enjoyable than typing. So maybe it’s a medium to force myself to code like in the old days. I was looking for something like spatial computing and all I could find were esolangs, UML, and maybe punchcards? This gives me an idea on how this could be useful.
minraws 2mo ago
Isn't all code 2d, what comes above and what's below matters in code, it isn't even necessarily a straight line, gotos are like teleportation or fast travel points, recursion is pretty interesting. I had difficulty reading large blocks of text when younger partly dyslexia I found out about much later, but mostly just overwhelming to look at. Then I learnt how to think of code as checkpoints, paths and basically a 2d map in a sense. It helped me get used to huge walls of text. Maybe since we now have AI we can do some fun stuff in this direction since human ergonomics for writing code matter less than making code fun to read so that we can read and validate massive AI code. Would be a fun experiment now that I think about it, I guess I found what I am doing tomorrow.
moritzwarhier 2mo ago
https://esolangs.org/wiki/Category:Two-dimensional_languages https://esolangs.org/wiki/Category:Two-dimensional_languages What I was looking for was actually "Piet": https://esolangs.org/wiki/Piet https://esolangs.org/wiki/Piet
Mohiuddin7 2mo ago
thats really, really cool, but is this implementable, for showcasing its good but what about practical? btw w
fatso784 2mo ago
Notational programming explored this, also with quantum computing, except the spatial notation was interleaved in a well-established 1d language (Python): https://dl.acm.org/doi/10.1145/3526113.3545619 https://dl.acm.org/doi/10.1145/3526113.3545619
utopiah 2mo ago
Turing Tumble is pretty fun.
sargstuff 2mo ago
A use case for unicode bidirectional algorithm[1] at language implimentation level. (vs. more traditioinal abstraction/logic level planes & normal to plane concepts: apl - hide it all in the language; spreadsheet - hide nothing/any information at any abstraction level is displayable[2][3][4][5]6]) -------------------------------------------------------------------------------- [1] Unicode bidirectinal algorithm : https://www.unicode.org/reports/tr9/ https://www.unicode.org/reports/tr9/ [2] spreadsheet : http://en.wikipedia.org/wiki/Spreadsheet http://en.wikipedia.org/wiki/Spreadsheet [3] sc-im - an ncuses spreadsheet program for the terminal: https://news.ycombinator.com/item?id=24318367 https://news.ycombinator.com/item?id=24318367 [4] Excel as a Turing-complete functional programming environment : https://eusprig.org/wp-content/uploads/2309.00115.pdf https://eusprig.org/wp-content/uploads/2309.00115.pdf [5] lambda the ultimate excell worksheet function : https://www.microsoft.com/en-us/research/blog/lambda-the-ultimatae-excel-worksheet-function/ https://www.microsoft.com/en-us/research/blog/lambda-the-ult... [6] escher circuits : https://esoteric.codes/blog/escher-circuits-using-vision-to-perform-computation https://esoteric.codes/blog/escher-circuits-using-vision-to-...
sargstuff 2mo ago
λ-2D: An Exploration of Drawing as Programming Language, Featuring Ideas from Lambda Calculus [0] One can use intensional calculus concepts to model non-lambda languages[3]. A live 'CoC'[6] / rocq[7] layer to hightlight/note 'correctness' issues (auotmated suggestion of proof of correctness/unresolved ANTLER freevars take on ast editors 'valid' language statement(s)/language block(s)) ast editor with gui nodes (panograph[1]) / code block with "user shape" construction using 3DILG[2]? 3d bar codes could be taken as a 'multi-statement' token. Piet[4][5] programming language might be more useful than 3d barcode as langauge token though (condensed spreadsheet). ----------------------------------------------------- [0] : https://www.media.mit.edu/projects/2d-an-exploration-of-drawing-as-programming-language-featuring-ideas-from-lambda-calculus/overview/ https://www.media.mit.edu/projects/2d-an-exploration-of-draw... [1] : https://github.com/jeprinz/pantograph/blob/main/README.md https://github.com/jeprinz/pantograph/blob/main/README.md [2] : https://1zb.github.io/3DILG/ https://1zb.github.io/3DILG/ [3] : [video] Beyond Lambda-Calculus: Intensional Computation calculus : https://news.ycombinator.com/item?id=49067361 https://news.ycombinator.com/item?id=49067361 [4] : piet examples : https://www.dangermouse.net/esoteric/piet/samples.html https://www.dangermouse.net/esoteric/piet/samples.html [5] : esolang Piet : https://esolangs.org/wiki/Piet https://esolangs.org/wiki/Piet [6] : calculus of constructions : https://en.wikipedia.org/wiki/Calculus_of_constructions https://en.wikipedia.org/wiki/Calculus_of_constructions [7] : rocq : https://en.wikipedia.org/wiki/Rocq https://en.wikipedia.org/wiki/Rocq

121 points by BinRoo 2mo ago

zellyn 2mo ago

I find it endlessly fun that one of the best environments for playing with befunge is written for the zmachine.

BinRoo 2mo ago

I ventured out to better read Qiskit code, and came back with this fun idea of 2D expressions

cavoirom 2mo ago

in the same spirit, checkout Orca: https://100r.co/site/orca.html https://100r.co/site/orca.html It is used to compose songs. You can see the demo in the linked page.

atoav 2mo ago
It is mentioned at the bottom of the page, but yeah Orca ia pretty good.

shevy-java 2mo ago

Soon we have an IDE that works in 3D. So, not only do you have to look left-right, then top-bottom, but also before, and behind. That's scaling code! You write in 3D now. Or, you stick to oldschool old people. Keep things simple.

ivanjermakov 2mo ago
I think humans are pretty good at thinking/operating in a 3D space. It's just that digital interface and programming tooling is not there. Obviously because usually there is no direct translation from domain model to physical 3D shapes. But it can well for those that translate: 3D modelling, spatial reasoning, motion tracking, mechanics, etc.
- xpct 2mo ago
  I imagine this varies by person, but thinking about a source file is already reminiscent of 2D space navigation, where the X axis is typically gated by conditions. In a similar vein, when I think about functions from different source files, I do hold some type of "depth", or "stacked panels" in my brain. I think this is because I reason about programs being in some state ~= being positioned at a certain function with some context I carry around. I'm sure it's not the only way to think about it, but it's a reasonable abstraction over what computers do. It's how we oriented our debuggers and early IDEs on as well, and carried this over to modern tools. Definitely something I'll be thinking about during the next few days.
  - ivanjermakov 2mo ago
    For real! Good contenders for 3 dimensions: individual expressions, call stack, time.
Towaway69 2mo ago
My approach is to start out with a 2D programming environment and once that becomes a general programming environment, to scale that up to 3D and explore how to map 2D to 3D. So first map 1D concepts to 2D and then move on. As a 2D representation, I've been using flow based programming (FBP)[1] and it's incarnation in Node-RED[2]. The trick here is to understand how to use FBP to create more generalistic programs, i.e., to prove it's Turing Complete. I think it would be a mistake to just start out with a 2D approach without also taking all the learnings we have made in 1D, i.e. TDD, OOP, KISS, DRY, Functional, Message Passing, Processes etc, and porting those to a 2D representation. [1]: https://jpaulm.github.io/fbp/ https://jpaulm.github.io/fbp/ [2]: https://nodered.org/ https://nodered.org/

jerf 2mo ago

"All this time we’ve been writing expressions in 1D space, but what happens when we unlock an extra dimension?" Text is a serialization of an n-dimensional work space. "N-dimensional" doesn't have a formal definition I'm aware of but the major characteristic of it is that a new dimension can pop up anywhere. If you feel like you want to double-click on that, you can see my earlier comment here: https://news.ycombinator.com/item?id=35096647 https://news.ycombinator.com/item?id=35096647 A conventional textual language can represent everything mentioned there, whereas 2D layouts struggle almost immediately to represent things that textual layouts represent quite easily. It can still be a useful "see the world differently" exercise, but it's the opposite of "freeing your mind"... it's stepping into a fairly small subset of functionality, albeit an unconventional one, and seeing what you can still manage to do even so. Rather than "unlocking a new dimension" it's actually throwing away n-2 of them. The experience of using this for any period of time would reveal this, as it would be a constant struggle to represent even very simple algorithms in this format. I post this mostly because of the "familiarity breeds contempt" effect that programmers seem to get hit with for text. There is a reason we use text and it's not lack of imagination or being stuck in our ways... it is actually an incredibly rich and powerful format that poses a serious challenge for any alternative to overcome because of the astonishing combination of compactness combined with representational power.

vitally3643 2mo ago
A certain subset of programmers apparently just really, really hate this whole messy concept of "thinking about things". Text works and is hard because it's a projection of a mental representation. The whole reason we can work with N-dimensional structures in text is because the dimensionality lives in the programmer's head. There isn't really any other way to represent say a >3 dimensional array other than laboriously flattening it into text and expecting the next guy to rotate the hypercube in his mind. That's neither a good nor bad thing, it's purely a fact of our 3+1 dimensional universe. A shocking number of problems can be best represented in higher dimensions and there's simply no way to encode that information losslessly. Being simple 3D creatures (I'd argue 2D in fact) the only way to do that is by projecting it down into a lower-dimensional space.
- 2mo ago

dahart 2mo ago

This is cute, and it’s fine and fun to play around, but I don’t know, takes itself way too seriously or something. I apologize for being negative, but blowing my mind? No, not exactly. The attempt at the end to justify isn’t compelling to me and feels pretentious or something; the so-called Sapir-Whorf hypothesis (a misnomer according to the link) is about words and concepts, not about layout. This article fails to consider how to say or to read 2D code, or even think about why text is normally 1D. Language is expressed in one dimension because of time. We don’t speak in 2D, because we can’t, therefore we don’t write in 2D. We do visualize parse trees as trees (2D pictures) all the time, which isn’t mentioned. Also not mentioned are all the massive downsides of trying to write & edit & maintain 2D code, as well as the fact that we have good ways to write 3+ argument functions in 1D. Nitpick - the andFlip function is wasting a whole dimension with unnecessary lines, and also modifying its input argument unnecessarily (yuck!), and it takes 3 arguments as an array for no good reason. Better: andFlip = lambda a,b,c : not c if (a and b) else c Except this is really just a normal 2 argument ternary, it does nothing interesting with a or b individually, it treats them as a unit, so I’d argue this shouldn’t even be a function.

pja 2mo ago

Was this post prompted by this year’s ICFP competition? https://icfpcontest2026.com/ https://icfpcontest2026.com/

levzettelin 2mo ago

This is just silly. The great gift of language is that it allows us to talk about arbitrarily complex things using a stream-like medium. Human speech is fundamentally 1D. The tree like structure of the concepts in language then facilitates the exponential growth in complexity. Or maybe centuries of human progress just went completely in the wrong direction? Unlikely. Nothing wrong with being silly, of course.

intrstng-stff 2mo ago

> Cube is a three-dimensional, visual, statically typed, higher-order logic programming language, designed to be used in a virtual-reality-based programming environment. In this paper, we give an informal overview of the language and describe a prototype implementation. https://marc.najork.org/papers/jvlc1996.pdf https://marc.najork.org/papers/jvlc1996.pdf

tikimcfee 2mo ago
I didn't know this paper existed and I'm excited to devour this. I've got my 3D glyph rendering system at glyph3d.dev, and use cases like this help accelerate layout and relationship development immensely. I greatly appreciate your sharing this! Would you happen to have a trove of similar research or papers I could sponge off of you? Or maybe even a few minutes of your time in some chats / emails to discuss how these tools can be brought to a modern runtime?
- utopiah 2mo ago
  Interesting, I'm relying on Troika (and a-troika-text for AFrame for WebXR) for https://git.benetou.fr/utopiah/text-code-xr-engine https://git.benetou.fr/utopiah/text-code-xr-engine

glouwbug 2mo ago

Anyone here ever use labview?

rogerdickey 2mo ago
Yeah. Love it! Used to make games with it, even

robertlagrant 2mo ago

> We don’t really see 3-arity functions written in infix notation much. Would a better example be Python's inline if else construction? x = 3 if thing else 4

DanielVZ 2mo ago

I was recently spending the last few days pondering how I would program in pen and paper if there were no technical restrictions other than having to define the program. I just started note taking by hand and I find it way more enjoyable than typing. So maybe it’s a medium to force myself to code like in the old days. I was looking for something like spatial computing and all I could find were esolangs, UML, and maybe punchcards? This gives me an idea on how this could be useful.

minraws 2mo ago

Isn't all code 2d, what comes above and what's below matters in code, it isn't even necessarily a straight line, gotos are like teleportation or fast travel points, recursion is pretty interesting. I had difficulty reading large blocks of text when younger partly dyslexia I found out about much later, but mostly just overwhelming to look at. Then I learnt how to think of code as checkpoints, paths and basically a 2d map in a sense. It helped me get used to huge walls of text. Maybe since we now have AI we can do some fun stuff in this direction since human ergonomics for writing code matter less than making code fun to read so that we can read and validate massive AI code. Would be a fun experiment now that I think about it, I guess I found what I am doing tomorrow.

moritzwarhier 2mo ago

https://esolangs.org/wiki/Category:Two-dimensional_languages https://esolangs.org/wiki/Category:Two-dimensional_languages What I was looking for was actually "Piet": https://esolangs.org/wiki/Piet https://esolangs.org/wiki/Piet

Mohiuddin7 2mo ago

thats really, really cool, but is this implementable, for showcasing its good but what about practical? btw w

fatso784 2mo ago

Notational programming explored this, also with quantum computing, except the spatial notation was interleaved in a well-established 1d language (Python): https://dl.acm.org/doi/10.1145/3526113.3545619 https://dl.acm.org/doi/10.1145/3526113.3545619

utopiah 2mo ago

Turing Tumble is pretty fun.

sargstuff 2mo ago

A use case for unicode bidirectional algorithm[1] at language implimentation level. (vs. more traditioinal abstraction/logic level planes & normal to plane concepts: apl - hide it all in the language; spreadsheet - hide nothing/any information at any abstraction level is displayable[2][3][4][5]6]) -------------------------------------------------------------------------------- [1] Unicode bidirectinal algorithm : https://www.unicode.org/reports/tr9/ https://www.unicode.org/reports/tr9/ [2] spreadsheet : http://en.wikipedia.org/wiki/Spreadsheet http://en.wikipedia.org/wiki/Spreadsheet [3] sc-im - an ncuses spreadsheet program for the terminal: https://news.ycombinator.com/item?id=24318367 https://news.ycombinator.com/item?id=24318367 [4] Excel as a Turing-complete functional programming environment : https://eusprig.org/wp-content/uploads/2309.00115.pdf https://eusprig.org/wp-content/uploads/2309.00115.pdf [5] lambda the ultimate excell worksheet function : https://www.microsoft.com/en-us/research/blog/lambda-the-ultimatae-excel-worksheet-function/ https://www.microsoft.com/en-us/research/blog/lambda-the-ult... [6] escher circuits : https://esoteric.codes/blog/escher-circuits-using-vision-to-perform-computation https://esoteric.codes/blog/escher-circuits-using-vision-to-...

sargstuff 2mo ago

λ-2D: An Exploration of Drawing as Programming Language, Featuring Ideas from Lambda Calculus [0] One can use intensional calculus concepts to model non-lambda languages[3]. A live 'CoC'[6] / rocq[7] layer to hightlight/note 'correctness' issues (auotmated suggestion of proof of correctness/unresolved ANTLER freevars take on ast editors 'valid' language statement(s)/language block(s)) ast editor with gui nodes (panograph[1]) / code block with "user shape" construction using 3DILG[2]? 3d bar codes could be taken as a 'multi-statement' token. Piet[4][5] programming language might be more useful than 3d barcode as langauge token though (condensed spreadsheet). ----------------------------------------------------- [0] : https://www.media.mit.edu/projects/2d-an-exploration-of-drawing-as-programming-language-featuring-ideas-from-lambda-calculus/overview/ https://www.media.mit.edu/projects/2d-an-exploration-of-draw... [1] : https://github.com/jeprinz/pantograph/blob/main/README.md https://github.com/jeprinz/pantograph/blob/main/README.md [2] : https://1zb.github.io/3DILG/ https://1zb.github.io/3DILG/ [3] : [video] Beyond Lambda-Calculus: Intensional Computation calculus : https://news.ycombinator.com/item?id=49067361 https://news.ycombinator.com/item?id=49067361 [4] : piet examples : https://www.dangermouse.net/esoteric/piet/samples.html https://www.dangermouse.net/esoteric/piet/samples.html [5] : esolang Piet : https://esolangs.org/wiki/Piet https://esolangs.org/wiki/Piet [6] : calculus of constructions : https://en.wikipedia.org/wiki/Calculus_of_constructions https://en.wikipedia.org/wiki/Calculus_of_constructions [7] : rocq : https://en.wikipedia.org/wiki/Rocq https://en.wikipedia.org/wiki/Rocq