Random Thoughts – Randocity!

CanDo: An Amiga Programming Language

Posted in computers, history by commorancy on March 27, 2018

At one point in time, I owned a Commodore Amiga. This was back when I was in college. I first owned an Amiga 500, then later an Amiga 3000. I loved spending my time learning new things about the Amiga and I was particularly interested in programming it. While in college, I came across a programming language by the name of CanDo. Let’s explore.


Around the time that CanDo came to exist on the Amiga, Apple had already introduced HyperCard on the Mac. It was a ‘card’ based programming language. What that means is that each screen (i.e., card) had a set of objects such has fields for entering data, placement of visual images or animations, buttons and whatever other things you could jam onto that card. Behind each element on the card, you could attach written programming functions() and conditionals (if-then-else, do…while, etc). For example, if you had an animation on the screen, you could add a play button. If you click the play button, a function would be called to run the animation just above the button. You could even add buttons like pause, slow motion, fast forward and so on.

CanDo was an interpreted object oriented language written by a small software company named Inovatronics out of Dallas. I want to say it was released around 1989. Don’t let the fact that it was an interpreted language fool you. CanDo was fast for an interpreted language (by comparison, I’d say it was proportionally faster than the first version of Java), even on the then 68000 CPU series. The CanDo creators took the HyperCard idea, expanded it and created their own version on the Amiga. While it supported very similar ideas to HyperCard, it certainly wasn’t identical. In fact, it was a whole lot more powerful than HyperCard ever dreamed of being. HyperCard was a small infant next to this product. My programmer friend and I would yet come to find exactly how powerful the CanDo language could be.


Amiga owners only saw what INOVATronics wanted them to see in this product. A simplistic and easy to use user interface consisting of a ‘deck’ (i.e, deck of cards) concept where you could add buttons or fields or images or sounds or animation to one of the cards in that deck. They were trying to keep this product as easy to use as possible. It was, for all intents and purposes, a drag-and-drop programming language, but closely resembled HyperCard in functionality, not language syntax. For the most part, you didn’t need to write a stitch of code to make most things work. It was all just there. You pull a button over and a bunch of pre-programmed functions could be placed onto the button and attached to other objects already on the screen. As a language, it was about as simple as you could make it. I commend the INOVATronics guys on the user-friendly aspect of this system. This was, hands down, one of the easiest visual programming languages to learn on the Amiga. They nailed that part of this software on the head.

However, if you wanted to write complex code, you most certainly could do this as well. The underlying language was completely full featured and easy to write. The syntax checker was amazing and would help you fix just about any problem in your code. The language had a full set of typical conditional constructs including for loops, if…then…else, do…while, while…until and even do…while…until (very unusual to see this one). It was a fully stocked mostly free form programming language, not unlike C, but easier. If you’re interested in reading the manual for CanDo, it is now located at this end of this section below.

As an object oriented language, internal functions were literally attached to objects (usually screen elements). For example, a button. The button would then have a string of code or functions that drove its internal functionality. You could even dip into that element’s functions to get data out (from the outside). Like most OO languages, the object itself is opaque. You can’t see its functions names or use them directly, only that object that owns that code can. However, you could ask the object to use one of its function and return data back to you. Of course, you had to know that function existed. In fact, this would be the first time I would be introduced to the concept of object oriented programming in this way. There was no such thing as free floating code in this language. All code had to exist as an attachment to some kind of object. For example, it was directly attached to the deck itself, to one of the cards in the deck, to an element on one of the cards or to an action associated with that object (mouse, joystick button or movement, etc).

CanDo also supported RPC calls. This was incredibly important for communication between two separately running CanDo deck windows. If you had one deck window with player controls and another window that had a video you wanted to play, you could send a message from one window to another to perform an action in that window, like play, pause, etc. There were many reasons to need many windows open each communicating with each other.

The INOVATronics guys really took programming the Amiga to a whole new level… way beyond anything in HyperCard. It was so powerful, in fact, there was virtually nothing stock on the Amiga it couldn’t control. Unfortunately, it did have one downside. It didn’t have the ability to import system shared libraries on AmigaDOS. If you installed a new database engine on your Amiga with its own shared function library, there was no way to access those functions in CanDo by linking it in. This was probably CanDo’s single biggest flaw. It was not OS extensible. However, for what CanDo was designed to do and the amount of control that was built into it by default, it was an amazing product.

I’d also like to mention that TCP/IP was just coming into existence with modems on the Amiga. I don’t recall how much CanDo supported network sockets or network programming. It did support com port communication, but I can’t recall if it supported TCP/IP programming. I have no doubt that had INOVATronics stayed in business and CanDo progressed beyond its few short years in existence, TCP/IP support would have been added.

CanDo also supported Amiga Rexx (ARexx) to add additional functionality to CanDO which would offer additional features that CanDo didn’t support directly. Though, ARexx worked, it wasn’t as convenient as having a feature supported directly by CanDo.

Here are the CanDo manuals if you’re interested in checking out more about it:

Here’s a snippet from the CanDo main manual:

CanDo is a revolutionary, Amiga specific, interactive software authoring system. Its unique purpose is to let you create real Amiga software without any programming experience. CanDo is extremely friendly to you and your Amiga. Its elegant design lets you take advantage of the Amiga’s sophisticated operating system without any technical knowledge. CanDo makes it easy to use the things that other programs generate – pictures, sounds, animations, and text files. In a minimal amount of time, you can make programs that are specially suited to your needs. Equipped with CanDo, a paint program, a sound digitizer, and a little bit of imagination, you can produce standalone applications that rival commercial quality software. These applications may be given to friends or sold for profit without the need for licenses or fees.

As you can see from this snippet, INOVATronics thought of it as an ‘Authoring System’ not as a language. CanDo itself might have been, but the underlying language was most definitely a programming language.

CanDo Player

The way CanDo worked its creation process was that you would create your CanDo deck and program it in the deck creator. Once your deck was completed, you only needed the CanDo player to run your deck. The player ran with much less memory than the entire CanDo editor system. The player was also freely redistributable. However, you could run your decks from the CanDo editor if you preferred. The CanDo Player could also be appended to the deck to become a pseudo-executable that allowed you to distribute your executable software to other people. Also, anything you created in CanDo was fully redistributable without any strings to CanDo. You couldn’t distribute CanDo, but you could distribute anything you created in it.

The save files for decks were simple byte compiled packages. Instead of having to store humanly readable words and phrases, each language keyword had a corresponding byte code. This made storing decks much smaller than keeping all of the human readable code there. It also made it a lot more tricky to read this code if you opened the deck up in a text editor. It wasn’t totally secure, but it was better than having your code out there for all to see when you distributed a deck. You would actually have to own CanDo to decompile the code back into a humanly readable format… which was entirely possible.

The CanDo language was way too young to support more advanced code security features, like password encryption before executing the deck, even though PGP was a thing at that time. INOVATronics had more to worry about than securing your created deck’s code from prying eyes, though they did improve this as they upgraded versions. I also think the INOVATronics team was just a little naïve about how easily it would be to crack open CanDo, let alone user decks.

TurboEditor — The product that never was

A programmer friend who was working towards his CompSci masters owned an Amiga, and also owned CanDo. In fact, he introduced me to it. He had been poking around with CanDo and found that it supported three very interesting functions. It had the ability to  decompile its own code into humanly readable format to allow modification, syntactically check the changes and recompile it, all while still running. Yes, you read that right. It supported on-the-fly code modification. Remember this, it’s important.

Enter TurboEditor. Because of this one simple little thing (not so little actually) that my friend found, we were able to decompile the entire CanDo program and figure out how it worked. Remember that important thing? Yes, that’s right, CanDo is actually written in itself and it could actually modify pieces that are currently executing. Let me clarify this just a little. One card could modify another card, then pull that card into focus. The actual card wasn’t currently executing, but the deck was. In fact, we came to find that CanDo was merely a facade. We also found that there was a very powerful object oriented, fully reentrant, self-modifying, programming language under that facade of a UI. In fact, this is how CanDo’s UI worked. Internally, it could take an element, decompile it, modify it and then recompile it right away and make it go live, immediately adding the updated functionality to a button or slider.

While CanDo could modify itself, it never did this. Instead, it utilized a parent-child relationship. It always created a child sandbox for user-created decks. This sandbox area is where the user built new CanDo Decks. Using this sandbox approach, this is how CanDo built and displayed a preview of your deck’s window. The sandbox would then be saved to a deck file and then executed as necessary. In fact, it would be one of these sandbox areas that we would use to build TurboEditor, in TurboEditor.

Anyway, together, we took this find one step further and created an alternative CanDo editor that we called TurboEditor, so named because you could get into it and edit your buttons and functions much, much faster than CanDo’s somewhat sluggish and clunky UI. In fact, we took a demo of our product to INOVATronics’s Dallas office and pitched the idea of this new editor to them. Let’s just say, that team was lukewarm and not very receptive to the idea initially. While they were somewhat impressed with our tenacity in unraveling CanDo to the core, they were also a bit dismayed and a little perturbed by it. Though, they warmed to the idea a little. Still, we pressed on hoping we could talk them into the idea of releasing TurboEditor as an alternative script editor… as an adjunct to CanDo.

Underlying Language

After meeting with and having several discussions with the INOVATronics team, we found that the underlying language actually has a different name. The underlying language name was AV1. Even then, everyone called it by ‘CanDo’ over that name. Suffice it to say that I was deeply disappointed that INOVATronics never released the underlying fully opaque, object oriented, reentrant, self-modifying on-the-fly AV1 language or its spec. If they had, it would have easily become the go-to deep programming language of choice for the Amiga. Most people at the time had been using C if they wanted to dive deep. However, INOVATronics had a product poised to take over for Amiga’s C in nearly every way (except for the shared library thing which could have been resolved).

I asked the product manager while at the INOVATronics headquarters about releasing the underlying language and he specifically said they had no plans to release it in that way. I always felt that was shortsighted. In hindsight for them, it probably was. If they had released it, it could have easily become CanDo Pro and they could sold it for twice or more the price. They just didn’t want to get into that business for some reason.

I also spoke with several other folks while I was at INOVATronics. One of them was the programmer who actually built much of CanDo (or, I should say, the underlying language). He told me that the key pieces of CanDo he built in assembly (the compiler portions) and the rest was built with just enough C to bootstrap the language into existence. The C was also needed to link in the necessary Amiga shared library functions to control audio, animation, graphics and so on. This new language was very clever and very useful for at least building CanDo itself.

It has been confirmed by Jim O’Flaherty, Jr. (formerly Technical Support for INOVATronics) via a comment that the underlying language name was, in fact, AV1. This AV portion meaning audio visual. This new, at the time, underlying object oriented Amiga programming language was an entirely newly built language and was designed specifically to control the Amiga computer.

Demise of INOVAtronics

After we got what seemed like a promising response from the INOVATronics team, we left their offices. We weren’t sure it would work out, but we kept hoping we would be able to bring TurboEditor to the market through INOVATronics.

Unfortunately, our hopes dwindled. As weeks turned into months waiting for the go ahead for TurboEditor, we decided it wasn’t going to happen. We did call them periodically to get updates, but nothing came of that. We eventually gave up, but not because we didn’t want to release TurboEditor, but because INOVATronics was apparently having troubles staying afloat. Apparently, their CanDo flagship product at the time wasn’t able to keep the lights on for the company. In fact, they were probably floundering when we visited them. I will also say their offices were a little bit of a dive. They weren’t in the best area of Dallas and in an older office building. The office was clean enough, but the office space just seemed a little bit well worn.

Within a year of meeting the INOVATronics guys, the entire company folded. No more CanDo. It was also a huge missed opportunity for me in more ways than one. I could have gone down to INOVATronics, at the time, and bought the rights to the software on a fire sale and resurrected it as TurboEditor (or the underlying language). Hindsight is 20/20.

We probably could have gone ahead and released TurboEditor after the demise of INOVATronics, but we had no way to support the CanDo product without having their code. We would have had to buy the rights to the software code for that.

So, there you have it. My quick history of CanDo on the Amiga.

If you were one of the programmers who happened to work on the CanDo project at INOVATronics, please leave a comment below with any information you may have. I’d like to expand this article with any information you’re willing to provide about the history of CanDo, this fascinating and lesser known Amiga programming language.


18 Responses

Subscribe to comments with RSS.

  1. Bernie said, on September 27, 2021 at 9:31 am

    I built an adventure creator program with Cando. In the same way that Cando could be used to create programs without “programing”, my program could be used to create text and graphics adventures without programming. Innovatronics was taken with my program and wanted to market it. It showcased what could be created with CanDo and gave me a marketing outlet. Unfortunately,as another fan described, through poor management at Commodore, the Amiga died as did Innovatronics. I thought Cando was a remarkable product and had hoped to see it reappear on Mac or PC but no such luck.

    Liked by 2 people

  2. Puha Technologies said, on April 4, 2021 at 4:04 pm


    I was searching for information about CanDo and this page came up. It seems like a interesting challenge to try to use CanDo to reverse engineer it self.

    What version of CanDo were you using? The first one from the 80s or a later version. There is also hyperbook for the Amiga made by some Canadians but they seemed to make their product rely more on the ARexx language so if you did not have ARexx (A500 K1.3) you were limited with what you could do with it. (Yes I know ARexx supports K1.2 upward, but it was not that common to have ARexx with a 1.x machine, well not in New Zealand also I was a child back in those days)

    Liked by 1 person

    • bigpoppa206 said, on November 8, 2022 at 9:50 pm

      Cando 1.0 arrived in 1989. The last official version released was Cando 3.0 in 1995 and could be upgraded with a patch that was released to the aminet network to version 3.08.

      Liked by 1 person

    • commorancy said, on November 8, 2022 at 9:56 pm

      Hi Puha,

      We were using versions before INOVA closed. After our project wasn’t approved, we didn’t pursue any further development work. I don’t know whether our project will work on the latest version. It might not.


  3. Lux said, on November 9, 2020 at 1:30 am

    So what happened to your TurboEditor? Any chance to open source it someday?


    • commorancy said, on November 10, 2020 at 9:43 pm

      TurboEditor didn’t get released. Without the blessing of INOVATronics, we couldn’t release it or risk violating CanDo’s legalize requirements. We ended up dropping the project, even though it was mostly finished. Even today, someone may still hold the rights to CanDo and could end up suing us for releasing TurboEditor as an alternative builder tool.


  4. bigpoppa206 said, on July 20, 2020 at 10:05 pm

    Have you ever seen Christian Effenberger’s CandoSDK? I thought I heard that Inovatronics sold him the code (around 1996/1997) and he then put out exactly what you guys were hoping to do. I believe there are examples still on Aminet. I loved Cando myself. Wrote a professionalized database for a music promotion company with it.


    • commorancy said, on July 24, 2020 at 11:24 am

      Thanks for your comment, bigpoppa206. I’d never heard of the CanDo code being sold to another individual for use in the CanDoSDK. Though, I suppose it’s entirely possible. However, in the mid-late 90s, they might have licensed the software to him for a period of time. I’d have to do more research to see who fully owns the CanDo code.

      Yes, it would be great to see if CanDo could be ported to today’s platforms and given a new life after the Amiga.


    • commorancy said, on July 24, 2020 at 11:56 am

      After doing a little bit more research, I think Christian may have done what we did with TurboEditor. Because CanDo is written in itself, he likely wrote an alternative and perhaps updated build interface using the standard CanDo libraries. An Aminet page I visited specifically states that the person running his CanDoSDK needs to own and use the CanDo 3.0 Libraries. That doesn’t indicate to me that he owned the code, but he may have been given a license. If he owned the code, he could have not only given out his SDK, he should also be able to give out (or sell) any necessary system libraries… which apparently he couldn’t do. That page even states that only registered CanDo owners can purchase the CanDoSDK… which may indicate he struck some kind of licensing agreement with the code owners. I believe the code still belongs to at least one of the original authors of it.


  5. marisagiancarla said, on July 7, 2020 at 2:41 am

    Hiya! About a month ago I set up a web community for CanDo fans. I am also in contact with one of the two devs to see about poissibly getting the source. Will post here if it goes anywhere. My community is at https://CanDo.AmigaCity.xyz – would love to see other fans there!


  6. chaotic3quilibrium (Jim O'Flaherty, Jr.) said, on May 4, 2018 at 4:14 am

    Hi. Nice article.

    I was with INOVAtronics. I did sales and tech support. The underlying language was AV1. The AV stood for Audio Visual. And Commodore filing bankruptcy in 1994/April was the final nail in the coffin for INOVAtronics.

    Liked by 3 people

  7. Marco Pontello said, on May 2, 2018 at 5:32 am

    Hi! Just find about CanDo while researching new filetypes for my TrID file identifier, and this was a nice bit of history to read, thanks! About the name of the language, that you say may have been PL1… Looking in a Deck file, in the Annotation chunk it’s written: “AV-1 Tokens V1”. Could it have been “AV-1” instead?


    • commorancy said, on May 2, 2018 at 5:53 am

      Hi Marco,

      AV-1 doesn’t feel familiar enough to me, but it’s possible. I still feel they gave it a name that was slightly different than that (a more programming generic name). The guys at INOVATronics were very careful not to use the actual programming language name when talking about or documenting CanDo. It was a name I don’t personally recall finding in the code. AV typically stands for audio-visual, which goes along with CanDo’s audio-visual programming style. The standalone programming language itself was a whole lot more capable than just performing audio visual programming. For this reason, the AV-1 name doesn’t feel familiar enough.

      Keep in mind, though, that the name was just for internal use so it doesn’t really mean a lot. In reality, the actual programming language was and always will be named CanDo. The internal name to which I refer was simply an internal name. Kind of like Return of the Jedi was code named ‘Blue Harvest’, but the movie was never called by that name.

      I should point out that even the INOVATronics guys admitted that the name given to the language itself was just a placeholder name and was never really used in any real sense.

      Thanks for your comment!

      Liked by 1 person

    • commorancy said, on May 4, 2018 at 8:06 am

      Hi Marco,

      Jim O’Flaherty, Jr who formerly worked at INOVATronics has confirmed that the underlying language name was, in fact, named AV1. I will update the article shortly.

      Liked by 1 person

  8. Samantha Atkins said, on April 1, 2018 at 12:35 pm

    Is the code available and manuals? Sounds like it needs an opensource project.


    • commorancy said, on April 1, 2018 at 12:43 pm

      Hi Samantha,

      A manual might be available somewhere via an Amiga archive. Though, it’s only likely to describe CanDo’s UI. Unfortunately, I don’t know the fate of CanDo’s source. When Inovatronics closed, I’m fairly certain the code died with them. As I kind of state in the article, I wish I had had the foresight enough to run down there and purchase its source code during their liquidation. Hindsight is always 20/20. Of course, I was a starving college student, which is the reason I owned an Amiga 500 and not a Mac.


    • commorancy said, on April 1, 2018 at 2:14 pm

      Hi Samantha,

      I just added in links to the CanDo manuals. Enjoy.


Comments are encouraged under these rules: 1. No personal attacks allowed. 2. Comments with personal attacks will not be posted. 3. Please keep your words civil. Thank you for contributing!

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

This site uses Akismet to reduce spam. Learn how your comment data is processed.

%d bloggers like this: