[Arathorn]

It’s ironic that the next graphical programming environment similar to Hypercard was probably Flash - and it obviously died too.

What actually are the best successors now, at least for authoring generic apps for the open web? (Other than vibe coding things)

[jx47]

I think that would be Decker (https://internet-janitor.itch.io/decker). Not my project but I found it some time ago when I searched for Hypercard successors. The neat thing is that it works in the browser.

[WillAdams]

This gets mentioned pretty much every time HyperCard is --- but I can't see that anyone has done anything with it.

Why use it rather than Livecode (aside from the licensing of the latter) or Hypernext Studio?

[RodgerTheGreat]

Some programs, games, and zines made with Decker: https://itch.io/games/tag-decker

Unlike LiveCode (or so far as I am aware HyperNext), Decker is free and open-source: https://github.com/JohnEarnest/Decker

HyperNext doesn't appear to be actively developed; the most recent updates I see are from last year, and it can't be used on modern computers. Decker's most recent release was yesterday morning.

I'd be happy to go into more detail if you like.

[WillAdams]

Livecode used to be opensource, which made me want to use it, but that window closed.

I guess I want a Flash replacement....

[leakycap]

https://ruffle.rs/ recently came to my attention when I needed to resuscitate a back into tool that had been completely built in Macromedia products

[jhbadger]

There's a fair amount of usage of it on Itch.io, if you are into that indie crowd. I was skeptical of it at first -- the whole 1-bit dithering aesthetic seems a bit too retro-twee, but I find it it is the best Hypercard-alike in terms of functionality -- it "just works" as compared to most Hyperclones that seem more like a proof of concept than a functional program.

[crucialfelix]

- Minecraft - Roblox - LittleBigPlanet - Mario Maker

This is what kids do to be creative.

Slightly more serious (and therefore less succesful): - Logo/Turtle Graphics - Scratch - HyperStudio

HyperCard was both graphic design and hypertext (links). These two modalities got separated, and I think there are practical reasons for that. Because html/css design actually sucks and never became an amateur art form.

For writing and publishing we got Wiki, Obsidian et al, Blogs (RIP), forums, social media. Not meant to be interactive or programmable, but these fulfill people's needs for publishing.

[WillAdams]

Yeah, that sums things up well --- the problem of course is what happens when one works on a project which blurs boundaries.

I had to drop into BlockSCAD to rough out an arc algorithm for my current project:

https://github.com/WillAdams/gcodepreview

(see the subsubsection "Arcs for toolpaths and DXFs")

Jupyter Notebooks come close to allowing a seamless blending of text and algorithm, but they are sorely missing on the graphic design and vector graphics front --- which now that I write that, makes me realize that that is the big thing which I miss when trying to use them. Makes me wish for JuMP, a Jupyter Notebook which incorporates METAPOST --- if it also had an interactive drawing mode, it would be perfect.... (for my needs).

[RossBencina]

Pretty sure the next after Hypercard was Macromind (later Macromedia) Director. I recall running an early version of a Director animation on a black and white Mac not long after I started playing with Hypercard. Later I was a Director developer. I recall when Future Splash released -- the fast scaling vector graphics were a new and impressive thing. The web browser plugin helped a lot and it really brought multimedia to the browser. It was only later that Macromedia acquired Future Splash and renamed it Flash.

[jonnytran]

Have you seen Scrappy? It’s still early, but it’s the most interesting thing I’ve seen in a while.

https://pontus.granstrom.me/scrappy/

[DonHopkins]

Flash completely missed the most important point of HyperCard, which was that end users could put it into edit mode, explore the source code, learn from it, extend it, copy parts of it out, and build their own user interfaces with it.

It's not just "View Source", but "Edit Source" with a built-in, easy to use, scriptable, graphical, interactive WYSIWYG editor that anyone can use.

HyperCard did all that and more long before the web existed, was fully scriptable years before JavaScript existed, was extensible with plug-in XCMDs long before COM/OLE/ActiveX or even OpenDoc/CyberDog or Java/HotJava/Applets, and was widely available and embraced by millions of end-users, was used for games, storytelling, art, business, personal productivity, app development, education, publishing, porn, and so much more, way before merely static web page WYSIWYG editors (let alone live interactive scriptable extensible web application editors) ever existed.

LiveCard (HyperCard as a live HTTP web app server back-end via WebStar/MacHTTP) was probably the first tool that made it possible to create live web pages with graphics and forms with an interactive WYSIWYG editor that even kids could use to publish live HyperCard apps, databases, and clickable graphics on the web.

HyperCard deeply inspired HyperLook for NeWS, which was scripted, drawn, and modeled with PostScript, that I used to port SimCity to Unix:

Alan Kay on “Should web browsers have stuck to being document viewers?” and a discussion of Smalltalk, HyperCard, NeWS, and HyperLook

https://donhopkins.medium.com/alan-kay-on-should-web-browser...

>"Apple’s Hypercard was a terrific and highly successful end-user authoring system whose media was scripted, WYSIWYG, and “symmetric” (in the sense that the “reader” could turn around and “author” in the same high-level terms and forms). It should be the start of — and the guide for — the “User Experience” of encountering and dealing with web content.

>"The underlying system for a browser should not be that of an “app” but of an Operating System whose job would be to protectively and safely run encapsulated systems (i.e. “real objects”) gotten from the web. It should be the way that web content could be open-ended, and not tied to functional subsets in the browser." -Alan Kay

>[...] This work is so good — for any time — and especially for its time — that I don’t want to sully it with any criticisms in the same reply that contains this praise.

>I will confess to not knowing about most of this work until your comments here — and this lack of knowledge was a minus in a number of ways wrt some of the work that we did at Viewpoints since ca 2000.

>(Separate reply) My only real regret about this terrific work is that your group missed the significance for personal computing of the design of Hypertalk in Hypercard.

>It’s not even that Hypertalk is the very best possible way to solve the problems and goals it took on — hard to say one way or another — but I think it is the best example ever actually done and given to millions of end users. And by quite a distance.

>Dan Winkler and Bill Atkinson violated a lot of important principles of “good programming language design”, but they achieved the first overall system in which end-users “could see their own faces”, and could do many projects, and learn as they went.

>For many reasons, a second pass at the end-user programming problem — that takes advantage of what was learned from Hypercard and Hypertalk — has never been done (AFAIK). The Etoys system in Squeak Smalltalk in the early 2000s was very successful, but the design was purposely limited to 8–11 year olds (in part because of constraints from working at Disney).

>It’s interesting to contemplate that the follow on system might not have a close resemblance to Hypertalk — perhaps only a vague one ….

SimCity, Cellular Automata, and Happy Tool for HyperLook (nee HyperNeWS (nee GoodNeWS))

https://donhopkins.medium.com/hyperlook-nee-hypernews-nee-go...

>HyperLook was like HyperCard for NeWS, with PostScript graphics and scripting plus networking. Here are three unique and wacky examples that plug together to show what HyperNeWS was all about, and where we could go in the future!

>The Axis of Eval: Code, Graphics, and Data

>Hi Alan! Outside of Sun, at the Turing Institute in Glasgow, Arthur van Hoff developed a NeWS based reimagination of HyperCard in PostScript, first called GoodNeWS, then HyperNeWS, and finally HyperLook. It used PostScript for code, graphics, and data (the axis of eval). [...]

>What’s the Big Deal About HyperCard?

>"I thought HyperCard was quite brilliant in the end-user problems it solved. (It would have been wonderfully better with a deep dynamic language underneath, but I think part of the success of the design is that they didn’t have all the degrees of freedom to worry about, and were just able to concentrate on their end-user’s direct needs.

>"HyperCard is an especially good example of a system that was “finished and smoothed and documented” beautifully. It deserved to be successful. And Apple blew it by not making the design framework the basis of a web browser (as old PARC hands advised in the early 90s …)" -Alan Kay

HyperLook SimCity Demo Transcript

https://donhopkins.medium.com/hyperlook-simcity-demo-transcr...

>[...] All this is written in PostScript, all the graphics. The SimCity engine is in C, but all the user interface and the graphics are in PostScript.

>The neat thing about doing something like this in HyperLook is that HyperLook is kind of like HyperCard, in that all of the user interface is editable. So these windows we’re looking at here are like stacks, that we can edit.

>Now I’ll flip this into edit mode, while the program’s running. That’s a unique thing.

>Now I’m in edit mode, and this reset button here is just a user interface component that I can move around, and I can hit the “Props” key, and get a property sheet on it.

>I’ll show you what it really is. See, every one of these HyperLook objects has a property sheet, and you can define its graphics. I’ll zoom in here. We have this nice PostScript graphics editor, and we could turn it upside down, or sideways, or, you know, like that. Or scale it. I’ll just undo, that’s pretty useful.

https://news.ycombinator.com/item?id=34134403

DonHopkins on Dec 26, 2022 | parent | context | favorite | on: The Psychedelic Inspiration for Hypercard (2018)

Speaking about HyperCard, creating web pages, and publishing live interactive HyperCard stacks on the web, I wrote this about LiveCard:

https://news.ycombinator.com/item?id=22283045

DonHopkins on Feb 9, 2020 | parent | context | favorite | on: HyperCard: What Could Have Been (2002)

Check out this mind-blowing thing called "LiveCard" that somebody made by combining HyperCard with MacHTTP/WebStar (a Mac web server by Chuck Shotton that supported integration with other apps via Apple Events)! It was like implementing interactive graphical CGI scripts with HyperCard, without even programming (but also allowing you to script them in HyperTalk, and publish live HyperCard databases and graphics)! Normal HyperCard stacks would even work without modification. It was far ahead of its time, and inspired me to integrate WebStar with ScriptX to generate static and dynamic HTML web sites and services!

https://news.ycombinator.com/item?id=16226209

MacHTTP / WebStar from StarNine by Chuck Shotton, and LiveCard HyperCard stack publisher:

CGI and AppleScript:

http://www.drdobbs.com/web-development/cgi-and-applescript/1...

>Cal discusses the Macintosh as an Internet platform, then describes how you can use the AppleScript language for writing CGI applications that run on Macintosh servers.

https://news.ycombinator.com/item?id=7865263

MacHTTP / WebStar from StarNine by Chuck Shotton! He was also VP of Engineering at Quarterdeck, another pioneering company.

https://web.archive.org/web/20110705053055/http://www.astron...

http://infomotions.com/musings/tricks/manuscript/0800-machtt...

http://tidbits.com/article/6292

>It had an AppleScript / OSA API that let you write handlers for responding to web hits in other languages that supported AppleScript.

I used it to integrate ScriptX with the web:

http://www.art.net/~hopkins/Don/lang/scriptx/scriptx-www.htm...

https://medium.com/@donhopkins/1995-apple-world-wide-develop...

The coolest thing somebody did with WebStar was to integrate it with HyperCard so you could actually publish live INTERACTIVE HyperCard stacks on the web, that you could see as images you could click on to follow links, and followed by html form elements corresponding to the text fields, radio buttons, checkboxes, drop down menus, scrolling lists, etc in the HyperCard stack that you could use in the browser to interactive with live HyperCard pages!

That was the earliest easiest way that non-programmers and even kids could both not just create graphical web pages, but publish live interactive apps on the web!

Using HyperCard as a CGI application

https://web.archive.org/web/20060205023024/http://aaa-protei...

https://web.archive.org/web/20021013161709/http://pfhyper.co...

http://www.drdobbs.com/web-development/cgi-and-applescript/1...

https://web.archive.org/web/19990208235151/http://www.royals...

What was it actually ever used for? Saving kid's lives, for one thing:

>Livecard has exceeded all expectations and allows me to serve a stack 8 years in the making and previously confined to individual hospitals running Apples. A whole Childrens Hospital and University Department of Child Health should now swing in behind me and this product will become core curriculum for our medical course. Your product will save lives starting early 1997. Well done.

- Director, Emergency Medicine, Mater Childrens Hospital

[rezmason]

You're right. Flash and its legacy would have been better if it had built in "Edit Source".

The earliest Flash projects were these artful assemblages of scripts dangling from nested timelines, like an Alexander Calder mobile. They were at times labyrinthine, like they are in many similar tools, but there were ways to mitigate that. Later on, AS3 code was sometimes written like Java, because we wanted to be taken seriously.

Many Flash community members wanted to share their source, wanted a space where interested people could make changes. We did the best we could, uploading FLA files and zipped project directories. None of it turned out to be especially resilient.

It's one of the things I admire about Scratch. If you want, you can peek inside, and it's all there, for you to learn from and build off of, with virtually no arbitrary barriers in place.