- Proyecto PALOMA was a sophisticated virtual processor concept by Paco Menéndez, creator of La Abadía del Crimen, designed in the 1990s but never published in his lifetime.
- Its original documentation, later released by El Mundo del Spectrum, revealed a rich instruction set with explicit latencies and an example algorithm that inspired a modern reimplementation.
- A community developer built and then fully rewrote a Python-based simulator to support all PALOMA instructions and timing behavior, releasing the source code as an open tribute.
- The project now serves as a living bridge between ZX Spectrum-era innovation, modern Python development and ideas that resonate with today’s AI and system architecture concerns.
There is something uniquely moving about seeing a long‑lost idea finally come to life on a modern machine. The story of Paco Menéndez and his mysterious project called PALOMA feels exactly like that: a blend of digital archaeology, personal tribute and hardcore computing nostalgia. For years, PALOMA was little more than an intriguing anecdote attached to the legendary Spanish game creator behind La Abadía del Crimen, one of the most iconic titles in the early history of Iberian video games.
Today, thanks to community effort and a Python-based simulator, PALOMA can actually be executed and explored. What once lived only in photocopied documents and half‑hidden notes can now run on your laptop using a language that defines modern programming: Python. In this article, we will walk through who Paco was, what the PALOMA project tried to achieve, how its algorithms have been reimplemented, and why this matters not only to Spectrum and retro fans, but also to anyone curious about the early foundations of ideas that now drive areas like artificial intelligence.
Who was Paco Menéndez and why does PALOMA matter?
To understand why so many people are excited about executing PALOMA in Python, you first need to know who Paco Menéndez was. For many enthusiasts of early Spanish computing, Paco is more than a programmer: he is a symbol of a creative and experimental era. If his name does not ring a bell immediately, you have probably at least heard of one of his most famous works, the game La Abadía del Crimen (The Abbey of Crime), a title that marked a before-and-after in the European 8‑bit gaming scene.
La Abadía del Crimen was developed for classic systems such as the ZX Spectrum and showed an extraordinary level of technical and narrative ambition for its time. Its complex structure, atmosphere and design turned Paco into a cult figure for many programmers who grew up in that generation. Over time, he stepped away from the video game world, but his reputation as a brilliant, unconventional mind never disappeared in Spanish-speaking computing circles.
One of the lesser-known chapters of his life is precisely the project we are talking about: PALOMA. This work did not become a commercial product or a widely published tool, and for a long period it remained semi‑forgotten. Only people close to Paco or particularly interested in the history of Spanish computing knew something about it, usually through fragmentary references and partial notes.
That is why the recent publication of PALOMA’s original documentation by the site “El Mundo del Spectrum” caused such a stir. For many, discovering that Paco had devoted a portion of his later years to designing a sophisticated algorithmic system was like opening a time capsule. The documentation did not just present a curiosity; it revealed a conceptual framework that, seen from today’s perspective, resonates strikingly with ideas that dominate modern computing and, in particular, certain approaches connected to AI and complex data processing.
What is the PALOMA project really about?
PALOMA is not a video game, nor a simple utility, but rather a conceptual “processor” and algorithmic framework designed by Paco Menéndez in the 1990s. The documentation released explains how this system was conceived as a kind of abstract machine, with its own instructions, latencies and way of handling data. The idea is that PALOMA can be simulated and executed in software, giving life to a custom-designed architecture and its algorithms.
The heart of PALOMA lies in a set of instructions and an example algorithm that illustrates how this virtual processor operates. That original example, included in the material shared by El Mundo del Spectrum, served as an entry point for enthusiasts who started to read the documents and felt, as more than one person has confessed, that their minds “exploded” at the sophistication and originality of the design, especially considering when it was created.
From today’s viewpoint, many of the ideas contained in PALOMA feel surprisingly close to mechanisms that move critical systems in the modern digital world. While it would be an exaggeration to say that PALOMA “invented” contemporary AI, its conception shows that Paco was exploring directions and abstractions that now appear in various areas, from advanced algorithm optimization to architectures specialized in data processing and decision flows.
The documentation suggests a deep focus on how information is transformed step by step, how latencies between operations influence global behavior, and how a set of instructions can orchestrate complex behavior. Those are concerns that resonate with anyone who has studied CPUs, virtual machines, low-level optimization or algorithms for intelligent behavior.
The cultural and emotional dimension is also crucial here: PALOMA was a personal and ambitious undertaking that, for tragic reasons, never reached the public in his lifetime. Paco’s untimely death made it impossible for him to refine or commercialize his idea, and for years the project seemed destined to remain just an unpublished gem. That is precisely what makes the current revival so special: not only does it rescue historical content, it also gives new generations the chance to interact with his design in a practical way.
From forgotten documents to a running Python simulator
The turning point came when a retro enthusiast and programmer read through the PALOMA documentation published by El Mundo del Spectrum and decided to bring it to life. According to his own account, once he had gone through the technical texts and understood the proposal, he felt compelled to try to simulate the project. The initial idea was modest: implement only the example algorithm that came with the original material.
That first simulator was limited, but it confirmed something essential: PALOMA could indeed be modeled and executed on a modern system. The conceptual architecture was consistent enough to be reproduced in software, and the example algorithm ran as expected, following the rules laid out by Paco. This alone would have been an interesting tribute, but the story did not stop there.
After experimenting with that small prototype, the developer realized that the initial version “fell short” of what PALOMA was capable of. The example algorithm only scratched the surface; the instruction set described in the documentation was much richer and more nuanced. That led to a second, far more ambitious phase: rewriting the simulator from scratch, this time including all the instructions defined by Paco and modeling their latencies accurately.
This second iteration truly transformed the project into a full interpreter or virtual machine for PALOMA implemented in Python. Instead of just faking behavior in a superficial way, the simulator now respected the timing characteristics (latencies) and semantics of each instruction. That step is vital for faithfully reproducing how the PALOMA processor was supposed to behave, especially in complex algorithmic scenarios.
Once the improved simulator reached a reasonably complete and stable state, its author chose to publish the source code openly. He shared this implementation in a comment on the news article that El Mundo del Spectrum had dedicated to PALOMA and to the homage being paid to Paco. That gesture turned what had been a personal tribute into a community resource, available for anyone who wanted to explore the project or even extend it.
Running Proyecto PALOMA in Python: what you can actually do
Thanks to the Python simulator, executing PALOMA’s algorithms is now a practical, hands-on experience rather than just an academic curiosity. Instead of limiting yourself to reading historical documents, you can load the simulator, feed it PALOMA-style programs and watch how the virtual processor behaves as it executes those instruction sequences.
The interpreter models the complete PALOMA instruction set, respecting the latencies described by Paco in his original design. That means each instruction not only performs a logical operation but also accounts for timing aspects that influence overall performance and algorithmic flow. For technically inclined users, exploring these latencies offers a glimpse into how carefully thought-out the system really was.
The original example algorithm included in the documentation becomes the natural starting point for experimentation. By running it through the Python simulator, you can compare the textual description with the actual behavior of the virtual machine, checking step by step how data is transformed and how control flows through the instruction sequence.
From there, more advanced users can try to write their own PALOMA-style programs. The simulator serves as a sandbox: you can extend or modify the instruction usage, craft more complex patterns and observe how instruction latencies accumulate or interact with control logic. This turns PALOMA into a kind of retro microarchitecture playground accessible through Python.
Although the implementation is written in Python, the concepts it embodies belong squarely to low-level systems thinking. You get to reflect on data paths, instruction scheduling, and execution costs in a way that is usually hidden behind high-level languages and frameworks. This makes the project appealing both to retro computing fans and to students of computer architecture who enjoy learning from historical designs.
Why people link PALOMA to the rise of AI ideas
One of the most striking reactions from those who have dug into PALOMA’s documentation is the feeling that Paco was, in some way, ahead of his time. Several readers have commented that when they finished going through the material, they were blown away by the parallels with concepts that today underpin systems central to the global digital infrastructure.
In particular, people often mention connections to the world of artificial intelligence and intelligent processing. PALOMA’s approach to structuring instructions, managing latencies and orchestrating complex operations evokes certain ideas used today when designing specialized processors, optimizing data flows, or modeling decision-making procedures. While the project itself is not an AI engine in the modern machine learning sense, its architecture reflects the kind of rigorous thinking that later became crucial in scalable intelligent systems.
This is especially impressive if you consider the historical context: Paco designed PALOMA in the 1990s, when many of these topics were not yet part of mainstream software development discourse. The deep attention to timing, instruction semantics and algorithmic structure foreshadows the kind of concerns we now see in high-performance computing and in the design of hardware accelerators for AI workloads.
For programmers and researchers who enjoy tracing the genealogy of ideas, PALOMA becomes a fascinating case study. It shows how someone rooted in the 8-bit era, known for crafting a groundbreaking adventure game, could later explore abstract architectures that harmonize with present-day concerns. That conceptual continuity between retro computing and today’s AI-intensive world is part of what makes this project so captivating.
Beyond the technical parallels, there is also a more philosophical aspect. PALOMA embodies the belief that carefully crafted instruction sets and well-structured algorithmic flows can yield surprisingly sophisticated behavior. That mindset, which values the expressive power of low-level design, remains highly relevant in domains where performance, control and predictability are essential, including certain AI and simulation workloads.
The emotional weight of a late homage
Behind the technical achievement of running PALOMA in Python, there is a story that is frankly emotional for many in the community. The programmer who reimplemented the project explains that Paco was one of his personal references, an idol from his youth as he discovered computing and video games in Spain. Learning of Paco’s death years ago had been deeply painful; discovering PALOMA’s documentation later was like reopening that chapter with a mix of admiration and sadness.
When he read the material published by El Mundo del Spectrum, he felt both intellectually challenged and personally compelled to act. Building the simulator was not just an exercise in reverse engineering or a geeky experiment; it was, above all, a tribute. Recreating PALOMA, instruction by instruction and latency by latency, became a way to honor the creative drive that had once inspired him to pursue computing.
The story took an unexpected turn when, after releasing the code in a comment on the PALOMA article, he discovered that a full piece had been written about his homage. His brother sent him the link, and he found himself featured in an article that recognized the effort to revive the project and the deep respect shown toward Paco’s work. That public acknowledgment was moving and helped spread knowledge of PALOMA even further.
For many readers and programmers who “hover” around retro computing forums, this entire chain of events has been particularly touching. It is rare to see such a clear bridge between a creative figure of the past, an unpublished visionary project, and a modern community that not only remembers but actively extends that legacy using contemporary tools like Python.
The publication of the source code, openly available for others to inspect and use, turns this homage into a shared endeavor. Anyone interested can download the Python files, examine the implementation choices, compare them against Paco’s original documentation and propose improvements or variations. In that sense, PALOMA has finally become a living project—no longer stuck in old papers but adaptable, modifiable and executable on today’s machines.
How this connects Spectrum, Python and the broader developer community
At first glance, linking the ZX Spectrum world with Python might seem strange, but PALOMA perfectly illustrates how these eras of computing are actually connected. Paco’s most famous public work belonged to the 8‑bit, cassette-loaded, memory-constrained landscape, while today’s Python-driven projects run on multi-core processors with abundant RAM and sophisticated operating systems.
Yet, under the surface, the same fascination with algorithms, architectures and clever use of limited resources remains. By implementing PALOMA in Python, the community effectively uses a modern, high-level programming language to reconstruct a highly specialized and carefully constrained virtual processor from the past. The tension between abstraction and low-level fidelity is part of what makes the exercise so interesting for developers.
This intersection speaks directly to programmers who grew up with retro machines and later adopted languages like Python for professional or hobby projects. For them, running PALOMA is a way to reconcile these two sides of their computing identity: the nostalgic attachment to Spectrum-era ingenuity and the practical comfort of modern development ecosystems.
At the same time, younger developers who never touched an 8‑bit machine can use PALOMA as an accessible window into that historical period. Instead of merely reading about old hardware, they can load a Git repository, run the simulator, and experiment with a virtual architecture designed decades ago. That combination of historical content and present-day tooling makes the project an engaging educational resource.
The fact that this entire narrative surfaced through online articles, forums and social networks underlines the role of the wider internet community in preserving and amplifying such stories. Even though some platforms restrict content when JavaScript is disabled or require modern browsers, the core of the discussion—forum posts, tributes, code repositories—remains accessible enough that enthusiasts can discover, share and expand upon PALOMA.
Ultimately, Proyecto PALOMA executed in Python shows how a single inspired design from the 1990s can resonate across decades, platforms and paradigms. What started as an unpublished idea by a brilliant Spanish programmer has turned into a community-driven, open code project that invites exploration, study and admiration. For retro fans, Python developers, AI enthusiasts or simply people who appreciate stories of overlooked genius, PALOMA offers a rare and rewarding journey through time, memory and code.
