Knight Lore Comes to Commodore VIC-20 in a Clever Isometric Port

Knight Lore reaches the Commodore VIC-20 in a resourceful port that reshapes its graphics, code, and classic isometric adventure for new hardware.

A Royal Adventure Finds an Unlikely Home

Some games seem tied to the machine that made them famous. Knight Lore is one of those adventures: its isometric rooms, chunky platforms, and strange little fantasy spaces feel inseparable from the ZX Spectrum era. Yet the game has now made an unexpected landing on the Commodore VIC-20, thanks to developer gekka.

That’s no small birthday-card conversion. The VIC-20 is a very different beast from the computer on which Knight Lore originally appeared, and its limitations force nearly every part of the game to be reconsidered. The result is less a simple copy and more a careful act of mechanical surgery.

At first glance, I expected the VIC-20 version to look cramped and compromised. That impression doesn’t survive much inspection. It certainly has to bend the original presentation, but the changes reveal a surprisingly thoughtful approach to squeezing an isometric adventure into a machine that wasn’t designed to handle conventional bitmap graphics.

The VIC-20’s Graphics Problem Comes First

Before Knight Lore can run, the VIC-20 has to solve a fundamental visual problem: it doesn’t offer a raster graphics mode in the usual sense. Instead, the image is built in character mode.

The computer’s basic display grid uses 22 by 23 character cells, with each cell measuring 8 by 8 pixels. Rather than drawing every pixel directly, the port creates its visuals by redefining the character set. In practical terms, the game assembles rooms, platforms, objects, and scenery from custom character shapes.

That technique sounds restrictive, and it is. Still, character graphics can be remarkably nimble in the hands of someone willing to work within the rules. The display resolution isn’t entirely fixed either; it can be adjusted within reasonable limits. Gekka took advantage of that flexibility to create a layout more suitable for the game.

The chosen resolution is 24 by 28, which gives Knight Lore a taller and slightly broader working area than the VIC-20’s standard arrangement. It also creates a mismatch with the 32 by 24 character-cell grid used by the ZX Spectrum, where the game first appeared.

That mismatch is the heart of the porting challenge. The original artwork cannot simply be dropped into the new display and expected to behave. Every tile and sprite has to be reshaped to fit a different kind of screen.

Shrinking Sideways, Stretching Upward

The solution is a little unusual. To make everything fit, the sprites and tiles were reduced to three-quarters of their original horizontal size, while their vertical size was increased to seven-sixths.

That sounds like the sort of mathematical compromise that might leave a game looking distorted, and in a strict sense, it does. The VIC-20 version isn’t trying to preserve the original proportions perfectly. It’s trying to preserve the recognizable structure of Knight Lore while making the new screen geometry work.

The horizontal squeeze is especially noticeable in the way rooms and objects occupy space. A platform may feel a touch narrower, while vertical elements gain a little extra presence. Yet this is preferable to allowing the playfield to spill awkwardly beyond the screen or reducing the entire game to an unreadable cluster of tiny marks.

Retro ports often reveal their compromises immediately. Here, the compromises are visible but purposeful. The game’s identity survives because the important shapes remain clear: the isometric floors, the platforms, the walls, and the objects that turn each room into a small spatial puzzle.

ImageMagick Does the Heavy Lifting

The visual conversion wasn’t built entirely by hand. Gekka openly admits that art isn’t the strongest part of the development process, so the original graphics were pushed through ImageMagick scripts.

That approach produced results described as serviceable rather than perfect. It’s a practical solution, though not a magical one. Automated image processing can resize and transform assets quickly, but it doesn’t always understand which details matter most to the human eye. A tiny adjustment to a character’s outline or an object’s edge can be the difference between “that’s clearly Knight Lore” and “that is probably a chair, perhaps.”

This is where a skilled pixel artist could make a real difference. The developer would have welcomed artistic assistance, particularly for cleaning up the converted graphics and making the resized assets feel more intentional.

That’s my mild reservation about the port: the technical ingenuity is easier to admire than every individual visual result. Some graphics inevitably look like they’ve passed through a machine before reaching the screen. Still, the alternative would have been an enormous amount of manual work, and the automated pipeline gets the project remarkably close to a playable visual language.

At first, I was tempted to see the scripted conversion as a shortcut. Thinking about the VIC-20’s display constraints changed my mind. The scripts aren’t replacing the design work; they’re handling the repetitive labor so the developer can focus on the much harder question of how the game should function on this hardware.

Why the BBC Micro Version Became the Foundation

The code side of the project follows an equally sensible path. Instead of starting from the ZX Spectrum version, the port uses the BBC Micro edition as its foundation.

The reason is inside the machines themselves. Both the BBC Micro and Commodore VIC-20 use processors from the same family: the MOS Technology 6502. That shared architecture makes the BBC Micro version a more practical starting point for adapting the underlying code.

Of course, “same processor family” doesn’t mean the job is easy. The code still had to be changed and optimized for the VIC-20. Memory behavior, display handling, and hardware-specific routines all need attention when a game moves between different computers.

The graphics procedures received particularly heavy revision. That makes sense, because the VIC-20’s character-based display demands a different strategy from the original game’s presentation. The port has to update custom characters, arrange them into the correct positions, and keep the on-screen action responsive without wasting precious resources.

This is the sort of work players rarely notice when everything goes well. You move through a room, hop between platforms, and think about the puzzle in front of you. Underneath, the machine is juggling a carefully rebuilt display system that has little in common with the original environment.

No Automated Code Generation in the Driver’s Seat

One detail stands out because it says something about the development philosophy behind the project: neural networks were not used to write the game’s code.

They were used to create tools, but the actual programming and optimization remained a hands-on process. That distinction matters. A tool can speed up asset preparation or help with repetitive tasks, while the architecture of the port still depends on someone understanding the target hardware and making deliberate decisions.

For an old computer such as the VIC-20, that practical knowledge is essential. Modern development habits don’t automatically translate to a machine with a tiny display grid and a processor from the 6502 family. The project succeeds or struggles at the level of individual bytes, screen cells, and carefully tuned routines.

There’s something pleasingly old-fashioned about that. Knight Lore may be arriving through modern development methods, but its survival on the VIC-20 still depends on the same kind of close relationship between programmer and machine that defined early home-computer software.

A Port Built Around Compromise

The most interesting thing about this release is that it doesn’t pretend the VIC-20 can behave like a ZX Spectrum. It accepts the difference and rebuilds the presentation around it.

The new resolution changes the proportions. The sprites and tiles no longer occupy space in exactly the same way. The graphics pipeline is partly automated, and the code has been substantially reworked. None of those choices are invisible, but each one serves the larger goal: making an isometric adventure function on a computer with a very different set of rules.

There’s also a little uncertainty in how faithfully every visual moment can be judged from the technical description alone. Without spending hours with every room and transition, I wouldn’t claim the port perfectly preserves the original rhythm or readability. The display changes are significant enough that the experience must feel somewhat different, even when the basic design remains familiar.

Still, that difference is part of the appeal. A port like this isn’t valuable only because it reproduces a known game. It shows what the VIC-20 can do when someone refuses to treat its limitations as a final answer.

Why This Knight Lore Port Matters

Classic conversions are often discussed as contests of accuracy: Which version has the sharpest graphics? Which one runs closest to the original? Those questions have their place, but they can miss the charm of projects such as this one.

The VIC-20 edition of Knight Lore is interesting because it demonstrates adaptation rather than imitation. Its character-mode graphics, altered proportions, and rewritten display routines are not minor technical footnotes. They are the reason the game can exist on this platform at all.

Gekka’s work also highlights how much effort can hide behind a familiar title. Players see a fantasy room and a few blocky objects. The developer sees a 24-by-28 layout, custom character definitions, resized assets, processor compatibility, and a pile of graphics routines that need to behave under pressure.

That’s the magic of retro development: the screen looks simple, but the decisions behind it are anything but.

The finished game is available as a downloadable release through the project’s community distribution channels, giving VIC-20 owners a chance to see how a landmark isometric adventure changes when it moves into a new mechanical home.

Заключение

Knight Lore on the Commodore VIC-20 is a clever reminder that old hardware still has room for surprises. The port doesn’t erase the limitations of the machine; it uses them as design boundaries, reshaping the graphics and code until the adventure can fit.

The visuals may not satisfy every purist, and the altered proportions take some getting used to. But after reconsidering my first reaction, I find the compromises more interesting than disappointing. Would you rather play a slightly reshaped Knight Lore on the VIC-20, or leave the machine without the adventure entirely?

ЧАСТО ЗАДАВАЕМЫЕ ВОПРОСЫ

• What is Knight Lore?
  Knight Lore is a classic isometric fantasy adventure originally released for the ZX Spectrum. Its gameplay centers on navigating room-based environments filled with platforms, objects, and spatial challenges.
• Why is the VIC-20 port technically difficult?
  The Commodore VIC-20 lacks a conventional raster graphics mode, so the game must build its visuals through character mode. The port uses redefined character shapes to create the scenery, sprites, and tiles.
• What display resolution does the port use?
  The port uses a 24-by-28 character-cell layout, which differs from the original ZX Spectrum arrangement of 32 by 24 character cells.
• Why was the BBC Micro version used as the coding foundation?
  The BBC Micro uses a processor from the same MOS Technology 6502 family as the VIC-20. That makes its version of the game a more suitable starting point for adapting the code.
• How were the graphics converted?
  The original graphics were processed through ImageMagick scripts. The resulting assets were resized to suit the VIC-20’s display, though the developer noted that assistance from an experienced artist could improve the final presentation.

Stay connected with more carefully restored retro-computing stories by subscribing to the newsletter.

architeg Основатель и главный создатель контента

Как основатель Console Classics, Валерий опирается на многолетний практический опыт в области ретро-игр, TCG и коллекционных предметов, чтобы предоставить вам достоверные новости, честные обзоры и советы экспертов, которым можно доверять.

См. полную биографию

Видеоигры Коллекционные Карточные Игры Аниме и Манга Железо и Софт