Last weekend I tried a few times to use both SwyftCard and Canon Cat emulators and in both cases didn't have a lot of success. This could be attributed to my ignorance of the emulators involved, but it made me second-guess my assumption that emulation would be the "easy way" to get to a Swyft-like machine I could take on the road.
But emulation isn't turning out to be the shortcut I expected it to be. It was a reminder of why I like to do things the hard way, and got me thinking about what it would take to write something of my own instead. Not as ambitious as an entire new computer, but a piece of software that I could run on whatever computer that had the essential things I've learned to love about the Swyft machines. Aside from being a stop-gap measure between having nothing and something, it might serve as an alternative to using an emulator for The Kitten, and while not likely to be directly usable for something like The Beaver, could help me work-out some of the design and conceptual ideas that would carry-over to a more complete project like either of them.
Also, it would be fun; more fun than fighting with other people's code that doesn't quite work for me.
This doesn't solve the other problems with using a contemporary computer, but after being reminded of textmode, I'm thinking if nothing else I could boot up into that and use a program like the one I'm talking about now and eliminate a lot of the instability, distractions and other disruptions to work that are provided by the "Desktop Environment".
So what would something like this look like?
The obvious answer would be to simply copy the features of the SwyftCard environment that I've been using for the last few months, and in effect that might be what happens, but I think it's worthwhile to look a little deeper into what makes these features so powerful and useful on a daily basis. It is these *ideas* that are where the inspiration should come from not simply their literal interpretation into the hardware and software of the Apple //e + SwyftCard. Aside from missing the point, simply blindly copying these things is likely to bring both the good, intentional behavior along with the baggage that exists in the SwyftCard implementation that was due to the nature and limitations of the hardware available at the time.
The ideas that stand-out to me, really the central idea is that Swyft alters the traditional relationship between applications and data. Instead of having multiple programs or applications to serve specific purposes Swyft is essentially a single program that provides an handful of parts that can be used to realize the functionality of several different applications. Several is an understatement as several examples are provided in the documentation but any number of existing or new applications can be realized through the use of the Swyft software.
This is a little bit like Hypercard, or a spreadsheet, or a database like Microsoft Access or maybe even something like a Jupyter Notebook but much more open-ended because the provided components are far more general-purpose: text data, fast universal search, integrated I/O (including communications) and a simple, embedded programming language.
Out of these building blocks many applications can be made. The examples provided in the documentation include a notebook, a journal, an address book and mail merge. Applications I've realized include a recipe database, a todo list, a calendar/datebook and various financial and electrical simulations.
A Swyft-inspired environment that provided these four components would match the capability of the SwyftCard that I've been working with these last few months, and should be fairly realizable in a text-mode program written in any of the languages I regularly use. Of course the devil is always in the details.
To live-up to it's inspiration this program needs ensure that all of these features are fast and that accessing them can become reflexive. That means they have one way to be accessed and always work as expected. No modes or other surprises. They all need to be accessible from the keyboard as well (something amazing about working with the SwyftCard is how I never have to take my hands off the keys). Something else the above doesn't capture is how all of this is realized with very few "commands"; for example, saving and loading a text from disk uses the same key combination; this is only possible because the software is smart enough to know automatically which way the data should be flowing, making it virtually impossible to loose work. That level of intelligence requires putting a lot of thought into the design of the software and the way it will be used and is not a trivial task for the designer and programmer.
Something else that this short list of features glosses over is the subtle details of inputting and working with text using the SwyftCard. The cursor/insertion point, the ways that text can be selected and moved and other aspects of manipulating text differ from every "text editor" that I've used and they take some getting used to, but once you get the hang of it you don't want to go back. For example, cut, paste and delete are simplified into deletion and insertion. Selecting and deleting text always preserves the deleted text in a buffer, which can then be inserted anywhere eise. This eliminates both a key command mapping and a mental decision point while working and while it might not sound like much, removing any amount of friction from the creative process means more of your mind doing what it does best.
There's numerous things like this that sand-down the surface of the tool and let you move through the work with less effort than anything else I've worked with, and it's speed and reliability let you develop the trust necessary to let go and flow without constantly stopping to make sure it's safe.
This is getting longer than I expected... I think I've done an OK job of identifying the key components and providing some examples that help convey the experience I want to recreate. I'll try to sharpen some of the more loosely-defined things about the experience into descriptions that are precise enough to be implemented and then take a whack at some sort of prototype.
Jason J. Gullickson, 2026