HN Reader

This is close to the functionality that Borland Delphi had back in the 1990s. The pascal language and the design of their GUI toolkit were a really good impedance match, so you could freely switch between GUI design and editing the text version of it.

Doing so for languages like C++, was a sea of boilerplate that you couldn't touch, which is why I never moved away from Pascal. Similar fragility was evident in WxPython and it's builder.

I'm glad to see that LLMs can provide a match for less well suited Language/GUI pairs. We all deserve to get that kind of productivity.

Hey nice - this stuff is so much fun to me. I've worked a number of experiments like this too, especially related to live coding. Love seeing it in the wild.

I built a small project where you can live-code Love2D. The running program updates in real time (no saving needed) and see all values update in real-time, via LSP.

https://github.com/jasonjmcghee/livelove

And also added the same kind of interactivity like a number slider and color picker that replace text inline, like yours (though via vs code extension: https://gist.github.com/jasonjmcghee/17a404bbf15918fda29cf69...)

Here's another experiment where I made it so you could "drag and drop" to choose a position for something by manipulating the editor / replacing a computed position with a static one, on keypress.

https://clj.social/@jason/113550406525463981

There's so much cool stuff you can do here.

For Slint [https://slint.dev], a (native) GUI Toolkit, I've also developed a LSP server that do live preview and editing. You can try it online at https://slintpad.com : if you click on the toolbar button to enable the right panel, you can edit the properties from the UI, and this is all done through the LSP and can be integrated in any editor that supports it.

This is a great idea: I'd never think of using LSP for this!

As a software developer, I always get frustrated when I am doing some graphical work and struggle to neatly parametrize whatever I am drawing (wooden cabinets and furniture, room layouts, installation plans...) and switch between coding where that makes most sense and GUI where it doesn't.

The best I've gotten was FreeCAD with Python bindings (I've got a couple of small libraries to build out components for me), but while you can use your own editor, the experience is not very seamless.

And then I start imagining tools like the one here, but obviously doing it just right for me (balancing the level of coding or GUI work).

It's concerning to me that the LSP idea is .. a thing. Casey Muratori observed years ago that it's just a way worse way of doing libraries. Like, you're introducing HTTP where there could just be a function call into a DLL/SO. What's the benefit there? Just make vim/emacs/$editor speak some native protocol and be done with it. Then you GUI is just welded directly into the running editor process.. right??

There's no security risk there that wasn't present before as far as I can tell because you were already planning on running the LSP on your local machine..

Isn’t the python based build123d the current best CAD in code solution? The problem with OpenSCAD is that it cannot export solid geometry, just a final mesh.

More broadly, I was genuinely shocked to realize, when I was playing with it, that there is no cross CAD file format that captures even simple design concepts like “this hole is aligned to the center of this plate” or even “this is a 2mm fillet”. STEP (the file format) mostly just captures final geometry.

I think CAD people just … redesign the part again if they need to move from say Fusion 360 to FreeCAD or whatever. How do they live like that?!

See https://new.rt.ht for bidi i⇄o sync demos!

The PDF ones are especially fun!

The whole playground is built for bidi sync!

It is referenced down in the wonderful tree of knowledge, but I thought I would lift this info up to the top level. A system like this called a "bimodal editor" from the work of Ravi Chugh [1] see the project Sketch-n-Sketch [2] these kinds of systems got a big kick in the pants with Bret Victor's talk Inventing On Principle [3]. That in turn kicked off a wonderful dynamic execution Clojure IDE called lighttable [4]

There are tons of other great research projects and researchers in this fascinating space. Comment is not meant to exclude.

[1] https://people.cs.uchicago.edu/%7Erchugh/

[2] https://ravichugh.github.io/sketch-n-sketch/

[3] https://vimeo.com/906418692

[4] https://web.archive.org/web/20250616031034/http://lighttable... (demo video plays)

While it doesn’t use an LSP (which is a great idea!), this project of mine does bidirectional mapping between a GUI and a shell pipeline:

Screenshots and GIFs for the explanation!

https://github.com/williamcotton/guish

I'm about to set off on this journey too with a code-first PCB editing suite for myself to work on. Seems like this is a good piece of prior art to reference as I need to build similar tooling. Thanks for posting!

We do quite a lot of this using webviews in vscode over at Darwinium. Similar process that involves postMessages between the UI container and the host containing the LSP. Biggest challenge I had with this was figuring out how to map a diagnostic from the language server (which is inherently range-based) to a UI component that would display it - it involves a fairly intricate pubsub system and mapping UI components explicitly to parts of a tree. Would love to share it eventually.

The idea of a language server also being some other kind of server is almost fiendishly clever to me and I'm shocked I hadn't seen other people play with this before. Definitely can think of applications to game programming -- a sufficiently dedicated engine team could fork their language's LS and allow you to e.g. integrate the map editor's feedback into the source code. I know hot-reloading is considered super valuable in games, but this is almost the dual of that idea. So clever!

Reminds me of the excitement I got on seeing https://www.youtube.com/watch?v=4tyTgyzUJqM. I still get excited about trying something like this again pretty much every time I see it. Have yet to really get any traction on anything. :(

A lot of folks had fun watching Minecraft built using a live code session, if I recall.

I've suggested this sort of interactivity for (Open)PythonSCAD:

https://lists.openscad.org/empathy/thread/GAX4QYYRUC3CEH572I...

The devil is in the details though, and I worry about the UI becoming cluttered and unmanageable.

I know it's not quite the same, and maybe it's just the demo video doing it, but this reminds me of the Light Table IDE http://lighttable.com/

I know basically nothing about CAD, but I know thet fornjot exists and wondered if it might be useful to your purposes, in case you don't know about that.

But well, the project is very cool and I love the idea of using LSP for something more!

Here's a similar example using lean widgets (in the live programming part of the talk): https://www.youtube.com/watch?v=c5LOYzZx-0c

Related: https://chromewebstore.google.com/detail/ghosttext/godiecgff...

> Write in the browser with your text editor.

This is awesome! If someone created a Interface Builder on top of that, I feel like I might even go back to making iOS apps. Xcode makes the whole experience so terrible that it sucks the joy out of it.

This is really interesting being able to do bi-directional editing. This is desperately needed for accessibility software to get at underlying text. I would use it for semantic editing of code by voice. However, getting at GUI elements would be amazing.

i wonder: could this kind of bidirectional flow be used to turn any LSP-capable editor (without it having to have any collaborative editing function integrated) into a collaborative editor that real-time-syncs any modification by any connected user with all other users who have the modified file open?

Very cool concept. Would love to see something like this for web development. Where making changes in the browser could be persisted seamlessly to code

This stuff is a dream of mine, editors in different modes that can collaborate seamlessly. Keep up the good work!

Whoa … you can use various unicode characters in titles on HN?

So if we replace LSP with MCP, the UI might control the code in interesting ways!

I guess it is about time for the usual Lisp, Smalltalk, Cedar and Oberon remarks.

Why do cool ideas take so much time to be embraced in mainstream?

Retoric question, naturally they weren't VC friendly with exponential growth capitalising user acquisition. /s

See also: zoo.dev, started by an acquaintance of mine.