gdsdecomp VS openscad-graph-editor

Tools like https://github.com/bruvzg/gdsdecomp exist, which is good if you need to recover your project.

The main contributor/developer behind Godot also released a very handy little tool that is capable of fully decompiling anything made with Godot:

https://github.com/bruvzg/gdsdecomp

It seesm exported game written in GDscript (I havnt tested with c#) is easily reversed into original source code state using tools (e.g. Godot RE Tools from https://github.com/bruvzg/gdsdecomp) and any one can take your source code.

With https://github.com/bruvzg/gdsdecomp it might as well be open-source anyway lmao

GDRE Tools, if you still have an exported artifact

Sounds like a job for GDRE Tools :)

unforunately godot games are unprotected by default. vast majority of godot games can be decompiled (and recompiled!) by gdsdecomp.

Pyinstaller has a single-executable option though, right ? As for reverse engineering, not sure that a godot game would be that much harder to decompile compared to pyinstaller, see example.

You should all try this: https://github.com/bruvzg/gdsdecomp

Try this

Finishing up yet another re-write of my current project:

https://github.com/WillAdams/gcodepreview

which I hope to then wrap up in a nice front-end using:

https://github.com/derkork/openscad-graph-editor

(or maybe some other tool --- is there a stand-alone, desktop version of Blockly which is extensible?)

Hopefully I'll also figure out how to write up a LaTeX package for the Literate Programming technique used and maybe a _TUGboat_ article.

Excellent points.

(much of the below has been posted in other discussions here, my apologies to folks who are seeing it for the _n_th time)

This is a sort of tool I've believed in/wanted for a long while (and I've been funding the author and chatting with him on Discord and via e-mail), but there seem to be a few fundamental issues which good answers need to be found for:

>What does an algorithm look like?

Can such visual tools be expressive enough to justify the effort?

They seem to work well for problems which can be expressed as one screen of diagram --- and while making modules would seem an easy way to increase the complexity, this goes against the initial mode of expression and if overdone, results in the wall-of-text one is trying to escape from, just dressed up in colored boxes and lines. Once one starts to scroll, or can't see the entire flow at a glance, things get complicated.

And of course, there are collections such as:

https://blueprintsfromhell.tumblr.com/

https://scriptsofanotherdimension.tumblr.com/

which might be used as arguments against.

I've been using:

https://www.blockscad3d.com/editor/

but it doesn't support all of OpenSCAD (and has some annoying bugs in what it does try to implement) and also funded:

https://github.com/derkork/openscad-graph-editor

but it has problems with a stylus (I have to leave the Windows Settings app open to toggle stylus behaviour which is enough friction that I don't use it as much as I would otherwise).

Hopefully the author will pop in and share a bit.

Quite a different problemspace, but there is:

https://github.com/derkork/openscad-graph-editor

which allows programmatic 3D modeling using nodes/wires. It exposes _all_ of OpenSCAD (last I checked) and is quite extensible (I use it to control a Python-enabled version of OpenSCAD https://pythonscad.org/ in an effort to make DXFs and G-code: https://github.com/WillAdams/gcodepreview )

Why did it have to be pixelated in appearance? It would be far more attractive as anti-aliased vector lines and type.

The red highlighting reminds me of electricity in the classic circuit problem game _Rocky's Boots_ on the Apple ][.

As I've posted in similar discussions: https://news.ycombinator.com/item?id=42051536

The problem here, as always is that there isn't an agreed-upon answer for the question:

>What does an algorithm look like?

The problem is expressiveness of such a diagram is bounded by the size of a screen or a sheet of paper, and once one starts to scroll, or can't see the entire flow at a glance, things get complicated.

The node/wire programming folks have this a bit rougher to the point that there are sites such as:

https://blueprintsfromhell.tumblr.com/

https://scriptsofanotherdimension.tumblr.com/

I prefer to work visually, but not sure if that's actually valid --- unfortunately https://www.blockscad3d.com/editor/ doesn't support all of OpenSCAD and https://github.com/derkork/openscad-graph-editor has problems with a stylus (I have to leave the Windows Settings app open to toggle stylus behaviour which is enough friction that I don't use it as much as I would otherwise).

There are promising tools though: https://nodezator.com/ and https://ryven.org/ are very cool.

Parallel track:

- MacBASIC: Mac GUI programming w/o Pascal or C https://www.folklore.org/MacBasic.html (which is something I'll never forgive Bill Gates for)

- HyperCARD: It was magic to get into Developer mode and to create stacks --- it's unfortunate that Asymetrix Toolbook didn't get further, and a shame that Runtime Revolution which became Livecode reneged on their opensource effort --- hopefully someone will make good on that: https://openxtalk.org/

Unfortunately, I never got anywhere w/ Interfacebuilder.app or Objective-C....

- OpenSCAD: Make 3D things w/o having to use a full-fledged CAD program

- BlockSCAD: Make 3D things w/o typing: https://www.blockscad3d.com/editor/ (though to be fair, https://github.com/derkork/openscad-graph-editor also allows that)

- PythonSCAD: variables and file I/O for OpenSCAD (though to be fair, RapCAD had the latter, it was just hard to use it w/o traditional variables) https://pythonscad.org/

Still working through a re-write of my OpenSCAD library in Python: https://github.com/WillAdams/gcodepreview and am hopeful that a tool like to https://nodezator.com/ will make that graphically accessible.

Nice! Great to see (Open)PythonSCAD listed! (I know this sort of thing is hard to keep up with --- I was trying for a long while on the old Shapeoko wiki (see link elsethread)).

A tool I'd suggest considering adding is:

https://github.com/derkork/openscad-graph-editor

(I guess it would fall under "GUI")

I'd give a lot to have a graphical development environment which:

- allowed drawing a user interface as naturally as I used to use Altsys Virtuoso (or Macromedia Freehand which I moved to when my Cube stopped working)

- allowed programming the UI as naturally as HyperCard (and to a lesser extent Lisp) "clicked" for me

- was as visual as Google's Blockly (which as BlockSCAD: https://www.blockscad3d.com/editor/ I've used a fair bit)

- exposed variables in a mechanism like to OpenSCAD's Customizer: https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/Customize...

Currently plugging away with OpenSCAD Graph Editor: https://github.com/derkork/openscad-graph-editor but hoping that: http://nodezator.com/ will become a viable option (still a bit bummed that I rolled and crashed w/ https://ryven.org/ though in retrospect, maybe I should try to tie that latter in to: https://pythonscad.org/ )

I use such tools when I can, and am fascinated with the concept, since it evokes Herman Hesse's _Glass Bead Game_ (from his novel _Magister Ludi) which was a book I remember fondly from my youth.

Advantages are:

- discoverability --- it seems pretty easy to arrange all elements in a hierarchy and make them accessible via clicking/revealing

- no syntax errors --- if things fit together/connect, then it should be a syntactically valid program

The problem is, it relies on a couple of concepts we don't seem to have a good solution for:

- What does an algorithm look like?

- How to deal with an algorithm which is larger than the current screen/window size? (it's all-too easy to have the same sort of problem of a not-wrapped program with lines longer than the current window size and more lines than will fit in a window, and there doesn't seem to be a 2D graphical equivalent of turning on word-wrapping)

- If programs are broken down into discrete modules, then connected together, one is back to the wall-of-text description which presumably one was trying to escape from, just wrapped up in boxes and connectors

Two pages with cautionary images are:

https://blueprintsfromhell.tumblr.com/

and

https://scriptsofanotherdimension.tumblr.com/

I've been trying to use OpenSCAD Graph Editor: https://github.com/derkork/openscad-graph-editor in my own work:

https://github.com/WillAdams/gcodepreview

and the screen grab from there sums up the difficulties pretty well:

https://raw.githubusercontent.com/WillAdams/gcodepreview/mai...