Malleable software: Restoring user agency in a world of locked-down apps
113 comments
·June 10, 2025WillAdams
Y_Y
Very pleased to see LyX and Ipe here. They've been invaluable throughout my academic career, and are just a pleasure to use (once you get the hang of them).
The Qt/KDE world has (imho) some of the best quality software I've used, and is, astonishingly, relatively unpopular compared to FOSS competitors.
Ipe now has a web interface (through the magic of Qt) and I remember there was a plan to make one for LyX, though if it ever happened, I couldn't find it.
gklitt
Neat —- Scrappy looks like a lovely prototype! As the creators say in their writeup, it fits nicely into the lineage of HyperCard-style “media with optional scripting” editors, which provide a gentle slope into programming.
In the section on dynamic documents towards the end of our essay, we show several of our lab’s own takes on this category of tool, including an example of integrating AI as an optional layer over a live programmable document.
jauntywundrkind
First two links right now both go to Scrappy, but your text makes it sound like you are contrasting different things?
WillAdams
I meant to note that Scrappy was discussed at the first link and then to provide the actual link --- my apologies if that wasn't clear.
moughxyz
Viberunner is another stab at this idea: https://news.ycombinator.com/item?id=44236729
eviks
> Mass-produced software is too rigid
Yes, absolutely, even trivial things like colors can rarely be changed, let alone more involved UI parts.
> Inflexible electronic medical records systems are driving doctors to burnout. > When different users have different needs, a centralized development team can’t possibly address everyone’s problems.
That's not the main issue, which is that they don't address *anyone's* problems well since actual users have very little power here, and the devs are far removed from actual user experience. Like that examples of filling useless fields - that serves no one!
> when a developer does try to cram too many solutions into a single product, the result is a bloated mess.
Unless it's organized well? There is no inherent reason many equals mess or even bloat (eg, if solutions are modules you can ignore/not even install, your app with only the solutions you care about has no bloat)
But in general, very laudable goals, would be very empowering for many users to live in a dream world where software is built based on such principles...
cosmic_cheese
I appreciate the idea behind the post, because certainly, we need more hackable apps now that everything is becoming a SaaS that effectively cannot be archived or hacked on (unlike, say, WinAmp or major releases of Windows and their respective fan updates, or for a more common example game mods).
Unfortunately I think that while there’s a decent number of power users and people who have the aptitude to become power users who will make use of software made to be deeply customizable, they are outstripped many times over by people who don’t see software that way and have no interest in learning about it. People are quick to point fingers about why the situation is as it is, but the truth is that it was always going to be this way once computers became widely adopted. It’s no different from how most people who drive cars can’t work on them and why few feel comfortable making modifications to their houses/apartments. There’s just a hard limit to the scope and depth of the average individual's attention, and more often than not technical specialization doesn’t make the cut. No amount of gentle ramping will work around this.
That doesn’t mean we shouldn’t build flexible software… by all means, please do, but I wouldn’t expect it to unseat the Microsofts and Googles of the world any time soon. I do however think that technically capable people should do anything they can to further the development of not just flexible, but local-first, hackable software. Anything that’s hard-tethered to a server should be out of the running entirely and something you can keep running on your machine regardless of the fate of its developer should take priority over more ephemeral options.
tikhonj
Pretty much everyone makes modifications to their homes— arranging furniture, choosing decorations, storing tools and implements and books and...
I've been to hotel rooms that looked identical to each other. I've never been to anybody's long-term home that wasn't unique—and unique in obvious, personalized ways. Even the most regularized housing ends up unique: I've visited everything from US dorm rooms to ex-Soviet housing blocks to cookie-cutter HOA-invested suburbs and yet, rules and norms aside, folks' private spaces were always unique, adapted through both conscious action and by unconscious day-to-day habits.
Just because 90% of these modifications did not need more DIY tools than the occasional hammer and nail does not mean they don't "count". That just shows that reducing friction, risk and skill requirements matters.
Gentle ramping helps in two ways. For people who would be inclined to get into more "advanced" modifications, it lowers the activation energy needed and makes it easier to learn the necessary skills. But even for people who would not be inclined to go "all the way", it still helps them make more involved modifications than they would otherwise. A system with natural affordances to adaptation lets people make the changes they want with less thought and attention than they would otherwise need—the design of the system itself takes on some of the cognitive load for them.
With physical objects like home furniture, the affordances stem from the physical nature of the item and the environment. With software, the affordances—or lack thereof—stem entirely from the software's design.
Mainstream software systems are clearly not designed to be adaptable, but we should not take this as a signal about human nature. Large, quasi-monopolistic companies are driven by scalability, legibility and control far more than user empowerment or adaptability. And most people get stuck with these systems less because they prefer the design and more because there are structural and legal obstacles to switching. The obstacles are surmountable—you can absolutely use a customizing Linux desktop day-to-day, I do!—but they add real friction. And, as we repeatedly see through both research and observation, friction makes a big difference to most people. Friction has an outsize impact not because of people's immutable preferences but, as you said, because people have finite pools of time and attention with too many demands to do everything.
tlarkworthy
I am making an offline-first thing that serialised to a single file that can be opened without a local Fileserver.
Still working on the UX a little but it seems close to what you want (and I agree). The vision statement is about creating immortal software exactly to fight bitrot https://github.com/tomlarkworthy/lopecode
bobajeff
Well with cars I think many would appreciate if they too were more malleable. My Dad has often told me of a car he once had that was really easy to repair (edit: it was a VW Beetle) as he was not known as someone who was terribly handy. Doubtful anyone would have that experience with today's cars.
scroot
> It’s no different from how most people who drive cars can’t work on them
What if instead of cars and driving, we use reading and writing as the metaphor for the kind of media/utility computing can have. I'd argue it them changes the whole nature of the argument.
trinsic2
Yeah, I'm gonna have to disagree with that. Computer users are shaped by the tools that they have available to them. There is always going to be a varying of degrees on how much a user gets in customization, but when the environment is designed around customization, users end up using the tools that are given to them.
cosmic_cheese
I’m not disagreeing with you, but rather suggesting that the ceiling for how much the average user can/will leverage customization is surprisingly low.
If we’re looking for levers to pull to help more people become advanced computer users, I believe progressive disclosure combined with design that takes advantage of natural human inclinations (association, spatial memory, etc) are much more powerful. Some of the most effective power users I’ve come across weren’t “tech people” but instead those who’d used iMac for 5-10 years doing photography or audio editing or whatever and had picked up all of the little productivity boosters scattered around the system ready for the user to discover at just the right time.
With that in mind, I think the biggest contributor to reduced computer literacy is actually the direction software design has taken in the past 10-15 years, where proper UI designers have been replaced with anybody who can cobble a mockup together in photoshop, resulting in vast amount of research being thrown out in favor of dribbble trends and vibes. The result is UI that isn’t humanist, doesn’t care to help the user grow, and is made only with looking pretty in slideshows and marketing copy in mind.
josephg
> I’m not disagreeing with you, but rather suggesting that the ceiling for how much the average user can/will leverage customization is surprisingly low.
The average person is also a crappy writer, bad musician and lousy carpenter. But a notepad and a pen don’t tell me how to use them. They don’t limit my creative capacity. Same story with a piano, or a hammer and chisel. I wish computers were more like that.
Your point stands. Most notebook users never use it to write a bestselling novel, or draw like Picasso. But the invitation to try is still in the medium somehow. Just waiting for the right hand.
I agree with the rest of your comment. As software engineers, we could build any software we want for ourselves. It’s telling that we choose to use tools like git and IntelliJ. Stuff that takes months or years to master. I think it’s weirdly perverted to imagine the best software for everyone else is maximally dumbed down. Thats not what users want.
Rather than aiming for “software that is easy to use” I think we should be aiming for “software that rewards you for learning”. At least, in creative work. I’m personally far more interested in making the software equivalent of piano than I am in making the software equivalent of a television set.
mynegation
Give me Delphi. No, seriously, give me Delphi, but for the web and in a modern popular programming language. Python would be great, but I will not turn my nose away from TypeScript or Go or Lua.
For those who don’t know, Delphi was (is?) a visual constructor for Windows apps that you outfitted with a dialect of Pascal. It was effing magic!
Nowadays the web ecosystem is so fast-paced and so fragmented, the choice is paralyzing, confidence is low. The amount of scaffolding I have to do is insane. There are tools, yes, cookie cutters, npx’s, CRAs, copilots and Cursors that will confidently spew tons of code but quickly leave you alone with this mess.
I haven’t found a solution yet.
WillAdams
Does the recently updated (and aptly named) Lazarus not suit?
https://news.ycombinator.com/item?id=43913414
A quick search yielded:
https://wiki.freepascal.org/Developing_Web_Apps_with_Pascal
and
https://www.reddit.com/r/pascal/comments/es8wlh/free_pascal_...
sea6ear
I've been playing around with the Godot game engine as a sort of modern successor to Delphi / Lazarus. I'm currently messing around with trying to create some database server management software using it.
GDScript is pretty similar in feel to Python, and you can also use C# if you want to. It has some level of GUI controls in the framework (not sure how many yet, but all of the GUI controls used to build the editor are available for use).
I want to believe the 3d capabilities might be useful for some kind of UI stuff, but I don't really have a real idea how to make that work - just a "wouldn't it be neat if..." question about it right now.
matt3D
I am currently using a stack which consists of:
- Makerkit Next.js/Supabase Starter Kit
- Python backend processing
- BMAD framework for building specification
- Claude Code with Max subscription
- Cursor for in IDE adjustments
I have managed to make some pretty incredible tools, it definitely feels like magic.
I would say I split my time 70% using BMAD as an assistant to build out my scope and clarify what I am trying to do in my own head, then 30% supervising Claude Code.
I have also managed to build out more simple tools using Streamlit to great effect
1899-12-30
Your best bet might be using blazor with a rad development tool, though I haven't tried it. blazor notably has devexpress components, which is what makes delphi tolerable.
felipeccastro
https://anvil.works/ uses Python
rkolodz
[dead]
Sophira
I've reverse-engineered a couple of programs before in order to get them to do what I want. Things like setting default options in a program that doesn't let you change the defaults, or getting older Windows programs to function correctly.
I've also patched open-source programs locally in order to get them to do what I want but wouldn't be suitable for upstreaming. For example, I've reverted the order of buttons in a "do you want to save?" close dialog when they changed in an update.
Minor stuff, but just being able to do this is amazing. The trouble is, developers - at least those of closed-source programs - don't want you to be able to do that, partially due to a lot of them relying on security by obscurity in order to earn money.
As such, it feels like the only way you're going to get developers to be on board with something like this is to be able to have them specify what people can change and what people can't change - and that's something that developers already do (whether they realise it or not) with things like INI files and the Registry.
This is why people using UNIX-based systems campaign for small programs that do one thing and do it well. Being able to combine these small programs into a pipeline that does exactly what you want? Now that's amazing.
zzo38computer
I have also patched open-source programs locally in order to get them to do what I want, although sometimes the program is very large and takes a long time to compile, while other times the program is much smaller and can compile more quickly. I had also sometimes modified binaries, or had entirely rewritten a program to get it to do what I wanted. Sometimes, I was able to do it by editing configuration files manually rather than using the UI, or by changing the permissions of files.
marklar423
Do you think it's possible to make GUI software with a Unix philosophy? Specifically piping together small programs seems natural in a shell but I've struggled to figure out how it could work for GUI apps.
rustcleaner
Copy ComfyUI's paradigm of connected components.
rerdavies
I hope you're looking carefully at COM/OLE Automation, which achieved pretty much all of those things.
- In-process and cross-process language-agnostic API bindings.
- Elaborate support for marshalling objects and complex datastructures across process boundaries.
- Standardized ways to declare application and document object models that can be used by external applications, or internally by application add-ons.
- A standardized distribution system for application extensions, including opportunities for monetization.
- Standardized tools for binding application APIs to web services and database services.
- A default scripting engine (VBA) that can be embedded into applications.
- Admittedly primitive and mostly ill-advised support for dynamically typed objects, and composable objects.
And it provides opportunities for all of the levels of application customization you seem to be looking for.
- Trivial tiny customizations using in-app VBA.
- The ability to extend your application's behavior using addons downloadable from a marketplace WITHOUT trying to capture a percentage of licensing revenue from those who want to monetize their add-ons.
- The ability to write scripts that move data between the published document object models of various applications (and a variety of standard data formats).
- The ability to write fully custom code that lives within applications and interacts with the UI and with live documents within those application (i.e. write-your-own add-ons).
Plus it would be enormously fun to build the equivalent functionality of COM/OLE with the all the benefits of hindsight, and none of the cruft incurred by Visual Basic, with lessons in hand from some of the things COM didn't do well. (svg as a graphics transport, perhaps? A more organized arrangement of threading model options? Support for asynchronous methods? A standardized event mechanism?)
Questions that come to mind:
- What can you get away with not doing that COM does do? Not much, I think.
- How could you make it better? A bunch of ways!
localhost
I used to own COM at Microsoft; I think that MCP is the current re-instantiation of the ideas from COM and that English is now the new scripting language.
mitchbob
There are people who like to tinker, to play with things, take them apart, learn how they work, put them back together again. Some of them go on to make new things. A few of them will make things that change the world. I'd like to live in a world that does more to encourage imagination and creativity, that lets people participate in creating their future. Software doesn't all have to be black boxes with No User Serviceable Parts Inside. We've seen what people can do with things like HyperCard, Visual Basic, Excel. And have fun doing it.
Triphibian
Though clearly imperfect video games have, at times, managed to reflect some of these principles. There was a brief moment at the peak popularity of World of Warcraft when the game was highly moddable -- if you walked up to a stranger's monitor you would not recognize the interface they were using for the game because they'd customized it so much.
The gaming audience is probably the most demanding of any regarding customization, modding, accessibility and other similar principles -- when the market forces line up and they are flush enough to offer more malleability video games frequently do.
fernmyth
As described in the article, sharing data between apps is currently impossible. I wish Solid/PODs had taken off, but I get the sense that project spent more time on ontologies and less on making useful things.
How can we draw apps into using a common data backend owned by the user?
carlosjobim
Almost all apps I use can export their data into common and open formats. If you make your workflow around common file formats instead of specific apps, then you can easier share data between apps.
AlexErrant
> we created Patchwork—a web-based collaboration environment for malleable software... storing both user data and software code in Automerge documents. On top of that, it adds version control utilities like history views and simple branching. These tools apply to any document in the system—whether a piece of writing, or code for a software tool... Eventually we also plan to release Patchwork as an open-source tool
What milestones would you like to hit before open-sourcing it? As an outsider, it looks like it has a LOT of features, and I wonder if there's feature creep. Still, version control for everything is a tall order, so perhaps it needs plenty of time to bake.
gklitt
Actually, Patchwork has surprisingly few features! Think of it more like an OS than a product. The goal is a small set of composable primitives that let you build many things - documents, tools, branching/diffs, plugins…
To answer your question: although we use Patchwork every day, it’s currently very rough around the edges. The SDK for building stuff needs refinement (and SDKs are hard to change later…) Reliability and performance need improvement, in coordination with work on Automerge. We also plan to have more alpha users outside our lab before a broader release, to work through some of these issues.
In short, we feel that it’s promising and headed in a good direction, but it’s not there yet.
seltzered_
In the 'Tools, not Apps' part of the article they reference Michel Beaudouin-Lafon's talk 'A World Without Apps' which goes back in time and shows the Xerox Star operating system: https://m.youtube.com/watch?v=ntaudUum06E&t=313s
Another reference I usually bring up is Alan Kay's talk on smalltalk: https://www.youtube.com/watch?v=AnrlSqtpOkw&t=4m19s
My related comments on this, just to show other stories along this theme:
- https://news.ycombinator.com/item?id=36885940
cadamsdotcom
Ink & Switch is doing great (some would say overdue) research that’s on the boundary of commercializability but outside the bounds of what the big corporates want to do with computers.
Great to see them pushing work like this, building experiments, and talking about what they’ve learned.
A tool which looks at this sort of thing which was mentioned here recently:
https://news.ycombinator.com/item?id=44118159
but which didn't seem to get much traction is:
https://pontus.granstrom.me/scrappy/
but it pretty much only works for JavaScript programmers and their friends (or folks interested in learning JavaScript).
Other tools which I'd like to put forward as meriting discussion in this context include:
- LyX --- making new layout files allows a user to create a customized tool for pretty much any sort of document they might wish to work on --- a front-end for LaTeX
- pyspread --- every cell being either a Python program or the output of a program, and the possibility of cells being an image allows one to do pretty much anything without the overhead of making or reading a file
- Ipe https://ipe.otfried.org/ --- an extensible drawing program, this really needs a simpler mechanism for that and I'd love to see a tool in the vector drawing space which addressed that --- perhaps the nascent https://graphite.rs/ ?