AI is everywhere. Just Google it, you’ll find books, videos, and news articles all over the place about AI and how AI will transform the world. What does this have to do with the Amiga, and specifically with AmigaOS 4?
One of the biggest challenges for users of any Amiga platform is the availability of modern software and access to modern tools. This is acute for the OS 4 platform. While there is fantastic software for AmigaOS 4, these tools have been handcrafted with love by heroic developers as passion projects.
What does this have to do with AI? Well, AI is VERY good at code generation, at least some of the tools are, and that is game-changing for AmigaOS fans. What these tools enable is for true hackers to elevate their game and produce viable tools with GUIs, built on open-source or whole-cloth projects.
I’m not going to dig into how these tools work or conduct any kind of review of them. This will focus on a journey I took using the Google AntiGravity IDE. What I learned and how I taught it to produce better Amiga code and to build C projects directly. Finally, test them in an emulator to experiment with unstable code without affecting my beloved PPC hardware.
While the order of the following actions does not matter too much, the power comes when all three come together to do cool stuff!
Setting up a common directory that all can see:
I recommend creating a directory on your primary workstation and sharing that directory via SMB. This will allow you to leverage that directory to enhance AntiGravity’s code generation via MPC, grant the build environment access, and finally provide your virtual and physical Amigas with access to the files and built executables. For my part, I created a folder called “Development-projects” on my D drive. More on this later.
Setting up AntiGravity:
I have been doing this on my Windows desktop, so I’ll tailor these directions to a Windows system. If you are doing this on Linux, it should be even easier!
To install Antigravity, do a Google search for “Google Antigravity” and follow the steps to download and install the application. At the time I’m writing this, Antigravity is in the preview phase, and they are lenient on billing for the AI searches. I subscribe to Google Workspace and get access to its AI tools, including the options Antigravity uses, which makes it an easy choice. I should add that Antigravity lets users choose which model to use and provides access to different modes, including Anthropic Claude.
While this focused on Antigravity, there are many options out there, so if you don’t like Google, do your research and pick the tools you prefer!
Empowering the AI to build OS 4 code:
This is an amazing enhancement to the process, as it allows the tool to write and compile code, identify and fix errors (when working with C or C++), and produce a binary. Wow!
The key to this superpower is Walkero's incredible work, which gives all AmigaOS 4 devs a simple way to cross-compile on Linux to build AmigaOS 4 binaries. You can get more details on the tool from his post here: https://os4coding.net/blog/walkero/how-cross-compile-amigaos-4
- To achieve this, install Docker on your Windows machine
- Launch Docker and select the Images page
- Search for “amigagccon” to find “Walkero/amigagccondocker” with a tag like “os4-gcc11”
- Click the “run” button
- Then select the options and select a local folder you set up before and map to /opt/code:
With the container downloaded and running, you can now tell AntiGravity to use that running container.
The MCP connection requires the “npx” command, which is part of Node.js and is not installed on the container gcc11-3.0.1 by default. Adding it is easy, just run these commands to ensure the correct version is installed 10.1.2+, if you use apt to install the native packages, you will get 9.x, and it will not work.
Now click the “Containers” option on the left, then the name of the container, then the “Exec” tab. This will take you to the command prompt so you can install “npx”:
Connecting AntiGravity to our GCC 11 container:
One of the really cool things about modern IDEs is their support for connecting to remote environments for development. In this case, we will connect to a container preconfigured for AmigaOS cross-compiling.
On the button to the left, there is a blue button:
Click that to get a window like this:
Select the “Attach to running Container”, then the container we started above should show up.
The main window should look like this:
Note: when you use the “open folder” to select your project folder, it will be relative to the container, so you will want to select the local directory you mapped to “/opt/code”.
Making better Amiga code with MCP:
Out of the box, AntiGravity will happily generate AmigaOS 4 code, but be warned, the results may be less than desirable… Why? Because this is an Amiga, and the AI tools often forget that when creating code. How do you fix that? Welcome to MCP, or Model Context Protocol.
While MCP is an expansive topic in its own right, in this case, we will use MCP to feed the AI engines a local folder containing examples of how to write proper AmigaOS code. I started with the AmigaOS 4 SDK and a few other projects I knew were well-written code. With all AI tools, it’s garbage in, garbage out, so be careful with what examples you use.
Setting up the MCP is easy. When I first did it, I used Google Gemini to help generate the JSON, and it took a few tries to get it right. So here's what I ended up with:
The most important step is to select a drive and folder that exist in the correct context. Remember, when AntiGravity is connected to Walkero’s container, that container is the context for which path to use, which should be something under “/opt/code/.”
The above JSON is pasted into the mcp_config.json file. You can access this file directly through the AntiGravity interface:
Click the Ellipsis in the upper right corner:
Select the “MCP Server” option:
Select “Manage MCP Server” in the upper right:
That will open a new tab in the IDE called “Manage MCPs”. On the right side are some action buttons:
From there, click “View raw config”, which opens another tab in the IDE with the title “{} mcp_config.json”. Paste the example MCP server I shared above here.
Close the tab, and “save”.
You might need to click the “Refresh” button to reload the raw configs. When it works, you should see this:
Let’s get virtual:
Enter Kyvos, an easy-to-use GUI for creating a QEMU-based virtual machine to build and launch systems running AROS, AmigaOS 4, and MorphOS. Beyond the amazing tool. Walkero has put together a phenomenal user guide that clearly walks through the process and provides details on attaching the AmigaOS 4 CD to install software, patching the OS to the latest levels, etc. You can get the tool and the doc from his Ko-Fi page for a small donation (please support him!!!): https://ko-fi.com/s/6476fdadd2
Since the provided documentation is so thorough, I won't dive into getting your virtual machine running; instead, I'll outline what I’ve done so I can integrate that OS into my coding workflow.
How best to share data with your virtual Amiga?
QEMU offers three options for sharing data:
- As a virtual USB drive
- As an SMB share by QEMU
- Using the network to talk to an SMB share
For my needs, I picked number 3. The first option is limited to 500MB of data, which is easily exceeded and will prevent the guest from starting. The second option can work, but you need to run smb2fs on the guest image to access the QEMU-presented folder, so it doesn't make sense when I’m already presenting the folder via SMB to my network. So I’ll just install smb2fs and configure it to talk to my normal share. This way, it’s consistent across all my Amiga systems.
I’d like to plug the brilliant UHCtools software. I love using the depotsearch and depotget commands to find and download software from the OS4depot to my guest OS from the CLI, no need to install or run a browser. Just get UHCtools into your guest, run the installer, then you can execute the following to get smb2fs:
From there, you can unpack and install smb2fs. To set up your share taylor this to match your environment:
Save that configuration to devs:dosdrivers/
Once active, you can use the cd command in the shell to navigate to your files.
System:> cd <sharename>:
Some final notes about the OS 4 guest. Enable the “USB tablet” option under Hardware to prevent mouse capture; it's not ideal for games, but it works well for app development. Currently, there is no way to share the clipboard between the AmigaOS 4 guest and the QEMU host. Who knows, maybe someone will follow this guide and use AI to create a tool to allow clipboard sharing!
Let's make some magic:
To review, we are in really good shape at this point. We have Antigravity set up, a local container running, and Antigravity can build Amiga-specific code and run it on the same machine where we're doing everything else!
A few other tips before you start:
Folders!
As someone who is NOT a developer and does not live inside an IDE all day, I had to get used to how AntiGravity worked. The key thing is your project folder. When you first launch AntiGravity, there is a big blue button:
Other stuff:
What is Vibe coding:
Vibe coming has become a hot topic in the programming world. The idea is you provide the AI engine with the spec, and the AI writes all the code. There is a detailed article here to deep dive into the concept. Following the news, I’ve found counterexamples: a team that Vibed an app and found it unsustainable in the long term because they did not know the code.
From my perspective, I’ve been working on a calculator app one prompt at a time. I started simple, build a window, add buttons, add calculations, add modes, add history window, support clipboard, add keyboard support, etc. During that process, each new feature broke the app, but through my manual testing and sharing the results, the AI bot resolved the issues and produced a working app.
I will upload the code to GitHub and post CalcuCraft to OS4Depot soon.
MCP vs Non-MCP examples:
As part of this, I wanted to see for myself whether using a local MCP repository would produce better code than the default AI models. To test this, I created the following prompt:
“Create a small tool that opens a window in the Amiga workbench titled "Widow test" with a single button that closes the window.”
Both methods produced a Window with a button, and both had issues.
https://github.com/billborsari/MCPTesting
Broken container connections with AntiGravity 1.16.5:
Google broke AntiGravity, and someone posted a fix:
Just need to execute that code on the container you wish to connect to, and it will start working! I’ve tried this with gcc1 and gcc6 containers from Walkero. Fingers crossed that versions above 1.16.5 will correct this issue.
Conclusion
Older Amiga users like myself have lived through the most consequential technological transformation in human history. We led the way in the beginning, but since 1993, the world has passed us by. Technologies such as multicore, multithreading, multi-CPU, and ultrafast memory and buses are out of reach, or at best, many generations away.
This AI revolution is different: with these tools, every innovation is immediately available to help us build more for our beloved platform.
Cheers,
Bill "tekmage" Borsari
