During my childhood, I often spent nights in local “Computing Centers,” skipping school and playing with Soviet IBM/360 clones. I became very familiar with their architecture and assembler language.
When I later got hold of a box of Soviet 4 KB memory chips, I had plenty of ideas about what to build. The idea of having a personal computer sounded fantastic. Someone from Finland even managed to deliver me a Z80 processor chip.
I had once seen an Apple Lisa at the Soviet Academy of Sciences, and it impressed me deeply. Being on the U.S. export‑restriction list, it had probably arrived in the USSR through Cuba, hidden in Apple boxes by the KGB. Scientists were given the machine to “study,” but they had no idea how such technology could be useful to them. They mostly worked with their Elbrus computers doing important military calculations.
Hardware Solution
With the components I had, I wanted to build something similar to the Apple Lisa.
I knew about floppy disks, but getting one myself was practically impossible. Therefore, reading and saving programs to a cassette tape was the only option. My keyboard had two special keys: Read from tape and Save to tape, which I pressed when the cassette player was ready.
Since the system saved a full memory dump, there was no concept of files or applications. After loading, you simply continued exactly where you had stopped before saving.
Colour TVs were expensive, bulky, and difficult to buy. However, the Soviet Union produced many small black‑and‑white suitcase TVs so people could watch propaganda while at their dachas or camping. A monochrome interface, similar to the Apple Lisa, was actually more convenient for me to code.
Software – Operating System
The GUI was implemented by switching memory blocks between main memory and graphics memory, and using the Z80 mov command to place pre‑calculated bytes into the correct positions. The Z80’s mov instruction was a major improvement over the Intel 8080, which still behaved like the old IBM/360 — copying memory byte‑by‑byte through processor registers.
I wanted my UI to support overlapping windows that the user could freely move and resize. Doing this in Z80 assembler required a lot of effort. You had to restore the background areas of windows, track their positions, and manage window hierarchy. Fortunately, I was already familiar with pointers — something IBM programmers rarely used.
Animated windows were important to me. New windows appeared by drawing from the center outward, expanding with a small delay in each direction. It looked nice and performed well.
I had no mouse, so the UI had to be controlled entirely with arrow keys and special key combinations. Soviet‑made microswitches were surprisingly good quality, and I especially liked their click.
My graphics and keyboard controllers were designed by an electronics‑savvy friend, so I never fully understood how they worked. I assume the keyboard did not use a serial interface and instead triggered processor interrupts directly into the correct register.
I also enjoyed designing “error messages.” They appeared as a small Smurf popping up with a speech bubble, written in my humorous tone rather than the old IBM style: “Error 33554 — please consult the manual.”
Usage Applications
Once the hardware and basic GUI were ready, I started thinking about what people could actually do with such a machine.
The first idea was to emulate a workplace desktop with the obligatory calendar, calculator, and clock. Obviously, the clock was the most important item in Soviet workplaces — so employees knew exactly when to go home.
Next, I implemented index‑card boxes as a kind of sequential database system. You dragged a box from the UI bookshelf onto the screen, and it opened your cards. You could design the card format and fields graphically by dragging elements into place. Since all data lived in memory, I didn’t need any database file format.
You could then write text into each card and give it a title. Clicking the title selected the card. I imagined this being used for contact cards, but it was powerful enough to create any kind of collection.
By this point, I had already implemented basic text‑editing functionality. So I decided to create another application: a Scientific Document Editor. I was still employed at the Academy of Sciences, programming mathematical models for scientists.
You could drag a document from the virtual shelf onto the screen and edit it. When writing text, you could define variables like x = 2.65 and y = 5.78, and later use them in formulas — the system calculated results automatically. Unlike typical computer math notation, my UI displayed formulas in proper scientific publication format: fractions with lines, Σ symbols for sums, and so on. I even wanted to add integrals, but that became too complex for my skills at the time.
A crucial feature was the ability to select and correct any previous text. Most editors of that era only allowed deleting the last character. Changing something in a previous paragraph meant deleting everything written after it. My editor allowed scientists to modify variables and instantly recalculate results.
Challenges
I encountered several programming challenges:
What Happened to It
When the Soviet Union began opening up, IBM PC clones appeared on the market. A PC clone with a Hercules graphics card and the GEM operating system continued many of the same principles. Microsoft Windows 1.0 was a joke. So for a short period, we coded similar applications for Hercules cards and GEM using C.
Eventually, graphics standards and card manufacturers became so fragmented that no one could keep up. That’s why Microsoft changed the market with Windows 3.1 — they allowed each manufacturer to install their own drivers. That was their success story. And Windows 3.1 was no longer as bad as the early versions. It remained the PC standard for nearly a decade until Windows 95.
