You'd roughly need to:

- Figure out which program is currently focused
- Figure out the Git repo of this software
- Clone it into a temporary directory
- Set up the required tools to start hacking on it and compile it

As a quick prototype, I wrote a li'l Bash script that does some of these things. It makes heavy use of #nix and #nixpkgs:

codeberg.org/blinry/view-sourc…

I enters a "dev shell" with the required tools already in the PATH, and even sets up a Git remote to start contributing. :D

Yeah, I've often wondered about that myself. I understand that you can install the Sugar DE on Linux, generally, and get that "view source" button. But it seems specifically designed to oppose multitasking, too.

en.wikipedia.org/wiki/Sugar_(d…

Well. Several idea pop up. The currently focused Application is easy to find. With something like apt-file you can find the package, download the source package and show that. That won't be much fun.

If you were to limit it to python-Apps, showing the directory of the python-file seems easy. Then you will want an overlay fs to not destroy the installed App, but write changes to "disk" and rerun the application from there.

oh oh oh talk to @EndlessAccess folks about this! They hold a defensive patent (which is usable by open source projects) for “Flip to Hack” which was this idea taken to the extreme as far as coolness goes.

I imagine @wjt, @ramcq, and maybe @chergert (because I think it used GNOME Builder?) could share some pointers to the history.

It originally ran Sqeak. Sqeak is a modern Smalltalk (though Pharo is positioning itself as a replacement). It was also inspired by the DynaBook, which was another of Alan Kay's projects.

Smalltalk environments all let you inspect both the source code and the state of running objects.

For Étoilé, we built a persistent object model with some common interfaces and the UI framework exposed the same introspection APIs, so you could attach an inspector to any object and see it in a generic way, but then attach an inspector to the UI for the model object, and then to that in turn and have inspectors all the way down (or up, or something).

Back in the 90s I taught myself HTML and CSS by using the view source feature in Netscape.

You can theoretically still do that if you can reverse the minification on modern websites.

Yes, see Lisp Machines, OpenGenera, Medley Interlisp, McCLIM, or almost any Smalltalk dialect. You can glimpse this in Emacs+SLIME »presentations«.

The system is »live«, and you can inspect it directly. Typically, this goes down to individual widgets.

»Modern« machines have lost the connection to their source, and trying to recover it with heuristics and remote repositories will necessarily be only a distant shimmer of that connection.

awesome idea. I know of a project inspired by olpc: balthazar.space/wiki/Balthazar

maybe you can collaborate

@enkiv2 Well there’s one at the bottom of every web site we make and all it takes is a link to a git remote somewhere :)

e.g. see footer of kitten.small-web.org/

Might be harder on native/proprietary platforms but I’d love to see this become a pattern that’s embraced on the web.

All #Smalltalk systems have that feature, I think. All #LOGO systems, similarly. Back in the day most #Lisp systems did, but that's largely gone out of fashion over the past 40 years. Interpreted language (e.g. #BASIC, #JavaScript, #Lua, #Python) programs necessarily come with user-editable source code, although this is sometimes deliberately obfuscated.

Even in pure compiled languages, most academic (and all #OpenSoirce and #Libre) programs come with user editable source.

Web browsers have always had this, of course.

What I'd like is an OS that comes with an interpreter for a decent language and which most of the default apps are written in. One that'd allow you to write simple little apps very quickly.

incidentally, Lisp Machines took it a step further where you could inspect and modify code of your running applications, and see changes live.

It's really sad to see that modern environments still haven't caught up to that.

tfeb.org/fragments/2025/11/18/…

Though crude, BASIC programs from 70s and 80s had that lovely feature as (often undesired) side effect. I didn't appreciate it for that at the time but i bet a lot of people did.

Most modern programs probably wont have that nice one to one correspondence.

This reminds me of a concept I "came up with" (certainly inspired by existing works) I dubbed WikiOS, to make your desktop environment as easy to edit as a wiki:
jawns.club/@skyfaller/10737492…
lobste.rs/s/ko5i9y/if_you_coul…

Obviously you are doing more to actually implement this vision than I am, but I just wanted to toss in more ideas about how you could empower users beyond "view source".

A "make this particular source code available" requirement is somewhat[0] baked into the AGPLv3 license, tons of discussion about showing code in use back then, I believe

Does PHP still have a "show the source code" option builtin?

[0] I think it's fully baked in, but it's been a long time since I looked at actual text of the license