{"id":2668,"date":"2026-08-12T07:55:00","date_gmt":"2026-08-12T07:55:00","guid":{"rendered":"https:\/\/alterego.cc\/wp\/?p=2668"},"modified":"2026-08-12T08:00:06","modified_gmt":"2026-08-12T08:00:06","slug":"amiblocks-and-amicc23-modern-c-development-comes-home-to-the-amiga","status":"publish","type":"post","link":"https:\/\/alterego.cc\/wp\/2026\/08\/12\/amiblocks-and-amicc23-modern-c-development-comes-home-to-the-amiga\/","title":{"rendered":"AmiBlocks and AmiCC23: Modern C Development Comes Home to the Amiga"},"content":{"rendered":"\n

Writing software for a classic Amiga in 2026 usually involves rather more modern hardware than the machine receiving the finished program. AmiBlocks wants to change that, and the compiler hiding underneath it may be even more interesting than the IDE itself.<\/em><\/p>\n\n\n

\n
\"Retro<\/picture>
AmiBlocks and AmiCC23 bring a modern edit-build-debug-run development workflow directly to classic AmigaOS.<\/figcaption><\/figure>\n<\/div>\n\n\n

There is a slightly peculiar contradiction at the heart of modern Amiga development. The Amiga software scene remains impressively active. New games appear, old software is maintained, utilities continue to emerge and programmers are still finding increasingly elaborate things to make 30- and 40-year-old machines do. Yet much of that software is no longer actually developed on an Amiga<\/strong>.<\/p>\n\n\n\n

A perfectly sensible contemporary workflow is to sit in front of a Windows, Linux or macOS machine, use a modern editor such as Visual Studio Code, compile with a cross-compiler and launch the result in an emulator or transfer it to real hardware. Some of the available tooling is remarkably sophisticated. Bartman\/Abyss’s VS Code Amiga extension, for example, combines C\/C++ compilation with GCC, WinUAE or FS-UAE integration, debugging and specialised profiling tools. It works. But it also means that your Amiga has effectively become the target rather than the development machine. AmiBlocks takes the opposite view.<\/strong><\/p>\n\n\n\n

Released by JPL64 alongside a new compiler toolchain called AmiCC23<\/strong>, it attempts to bring the modern IDE workflow back onto the classic Amiga itself. The idea is wonderfully straightforward: create the project, write the code, build it, debug it and run it without leaving AmigaOS. That alone makes AmiBlocks interesting. AmiCC23 makes it considerably more ambitious.<\/p>\n\n\n\n

An IDE that behaves like an IDE<\/h2>\n\n\n\n

Anyone who has programmed on older machines will know the ritual. Open an editor. Save the file. Open a Shell. Run the compiler. Discover that line 147 contains something stupid. Return to the editor. Compile again. Run the executable. Reach for a separate debugger. Wonder why you chose programming rather than gardening. None of these individual steps is particularly difficult, but the friction accumulates. AmiBlocks tries to remove it.<\/p>\n\n\n\n

The IDE is openly inspired by Code::Blocks<\/strong>, and the influence is obvious in the philosophy rather than simply the appearance. Projects and workspaces sit alongside a multi-file editor; syntax colouring, code folding and multiple tabs make source navigation less primitive; compiler messages and build logs appear inside the environment rather than disappearing into another Shell window. There are project templates, build configurations and integrated execution. The development loop effectively becomes: Create \u2192 Edit \u2192 Build \u2192 Debug \u2192 Run.<\/strong> That sounds entirely unremarkable if your daily machine has Visual Studio, Xcode or JetBrains installed. On a classic Amiga, that is precisely why it matters.<\/p>\n\n\n\n

AmiBlocks also includes source-level debugging facilities with breakpoints, stepping, variable watches, debug output and memory inspection. A dedicated memory viewer can display an address or pointer in hexadecimal and ASCII, which is exactly the sort of feature that becomes rather useful when your idea of application development includes poking hardware and finding out which innocent pointer just sent the machine into orbit.<\/p>\n\n\n\n

The debugger is not being presented as finished. Its developer specifically says that source-level behaviour and reliable breakpoint handling remain areas of active development and testing. That distinction matters. AmiBlocks looks ambitious, but its itch.io page still officially labels the project \u201cIn development.\u201d<\/strong><\/p>\n\n\n\n

The bigger surprise is AmiCC23<\/h2>\n\n\n\n

An integrated editor would have been noteworthy on its own. Writing a new compiler toolchain to accompany it is another level of commitment entirely. AmiCC23 is not simply AmiBlocks launching GCC behind the scenes.<\/strong> According to its developer, it is a separate compiler toolchain being developed specifically around modern C and native Amiga code generation. Its target language is ISO C23<\/strong>. That is quite a statement when attached to a Motorola 68k platform. C23 is not marketing shorthand for \u201ca reasonably recent version of C.\u201d It corresponds to the current ISO\/IEC 9899:2024 specification for the C programming language.<\/p>\n\n\n

\n
\"Three-panel<\/picture>
Modern PCs may have taken over much of the Amiga development workflow, but AmiBlocks wants to put the classic machine back in the developer\u2019s seat.<\/figcaption><\/figure>\n<\/div>\n\n\n

The work described for AmiCC23 covers the complete chain rather than just parsing a few newer keywords: preprocessing, syntax and semantics, types and conversions, expressions, functions, structures and unions, code generation, assembly\/start-up, linking, runtime support and parts of the hosted C library. Conformance testing is also part of the development plan. Importantly, the developer is not claiming complete C23 conformance yet<\/strong>. The stated intention is to publish more detailed conformance information once testing justifies such claims. That is the right attitude.<\/p>\n\n\n\n

Creating a compiler is one of those projects that can move from \u201cthis is working surprisingly well\u201d to \u201cI have spent three days investigating integer promotion rules\u201d with remarkable efficiency. Full standards compliance is a much higher bar than successfully compiling example programs. But even an increasingly complete C23 implementation targeting classic AmigaOS is fascinating.<\/p>\n\n\n\n

It represents a different philosophy from simply preserving an old development environment. Rather than asking programmers to step back into the C dialect and workflow of the early 1990s, AmiCC23 is trying to bring the language forward while leaving the target machine where it is.<\/p>\n\n\n\n

This project has moved quickly<\/h2>\n\n\n\n

Contemporary coverage described a Code::Blocks-inspired native IDE with project browsers, syntax colouring, build panes and GNU GCC\/GNU Make integration. The published requirements at the time were AmigaOS 3.1, a 68020 processor, a HiRes display and 4 MB of RAM, with 8 MB suggested for larger projects or several large source files. The August package is considerably more ambitious in how it is presented.<\/p>\n\n\n\n

The current itch.io release combines AmiBlocks with AmiCC23 and describes native compilation, project management, debugging and execution as a single system. The package is remarkably small by modern standards too: the listed Full archive is around 1.3 MB, while the Free package is roughly 1 MB. There is something pleasingly Amiga about an entire development environment being measured in the same units that modern applications reserve for a handful of toolbar icons.<\/p>\n\n\n\n

The itch.io title also advertises C\/C++, 68k assembly and ARexx<\/strong>, while the detailed launch announcement concentrates predominantly on C and AmiCC23. The Full edition additionally advertises support for external SDKs. That suggests AmiBlocks is intended to become broader than simply a front end for its new compiler.<\/p>\n\n\n\n

Native development is the point<\/h2>\n\n\n\n

It would be easy to judge AmiBlocks against modern cross-development environments and conclude that the latter are inevitably more powerful. They probably are. That misses the point. If maximum productivity is the only objective, a contemporary PC with a fast compiler, several gigabytes of source indexing, Git integration, language servers and a modern debugger has an advantage that a 68030 is unlikely to overcome through enthusiasm.<\/p>\n\n\n\n

There are already mature Amiga cross-compilation options. AmigaPorts maintains a GCC-based toolchain containing GCC, binutils and supporting Amiga tools, while the VS Code ecosystem can provide integrated compilation, emulation and debugging on modern hosts. AmiBlocks is solving a different problem. It is for someone who wants the Amiga to remain the computer<\/strong>, not merely the thing being emulated at the end of a build script. That distinction is difficult to quantify but very easy to understand if you still use classic machines.<\/p>\n\n\n\n

Writing a program on an Amiga, pressing Build and having that same machine generate and execute its own native program creates a completely different experience from editing on a 2026 workstation and firing the result into WinUAE. Neither approach is more legitimate. One is simply considerably more Amiga.<\/p>\n\n\n\n

The free version is genuinely useful, with one catch<\/h2>\n\n\n\n

JPL64 has taken a fairly sensible approach to trying the software. The Free edition<\/strong> reportedly allows projects to be created, compiled, run and debugged without watermarks or restrictions on source-code size or resulting executable size. There is no subscription. The limitation is time. Each session lasts 10 minutes<\/strong>. According to the developer in the Reddit discussion, you can restart the program and begin another ten-minute session as many times as you like.<\/p>\n\n\n

\n
\"Three-panel<\/picture>
Modern cross-development can make Amiga programming faster and easier, but from the Amiga\u2019s point of view it sometimes feels less like development and more like being handed the final exam.<\/figcaption><\/figure>\n<\/div>\n\n\n

That is enough to establish whether AmiBlocks runs properly on your system and whether you like the general workflow. It is considerably less attractive as a permanent development environment unless your coding style consists entirely of very short bursts of productivity.<\/p>\n\n\n\n

The Full version removes that limitation and adds the more substantial features: complete source-level debugging, breakpoints, advanced build configurations, multiple projects and workspaces, external SDK support, the full set of templates and examples, documentation and priority support.<\/p>\n\n\n\n

There are still unanswered questions<\/h2>\n\n\n\n

AmiBlocks deserves enthusiasm, but it is much too early for an unquestioning victory lap. The compiler is new. Its C23 conformance is unfinished. The debugger is still being refined. The project itself is officially in development. There are also practical questions that documentation cannot answer.<\/p>\n\n\n\n

How comfortable is the IDE during a lengthy session on a modest 68020 or 68030? How quickly does AmiCC23 compile a substantial project? How good is the generated 68k code? How compatible is the runtime with existing libraries and SDKs? How reliable are breakpoints when debugging less trivial applications? How easily can an established GCC, SAS\/C or VBCC codebase be migrated?<\/p>\n\n\n\n

Those answers need actual software written with the thing, preferably on real hardware. And that is probably the most interesting stage of the project. A compiler becomes important not when it successfully compiles Hello World<\/code>, but when somebody uses it to make something they genuinely wanted.<\/p>\n\n\n\n

Who is AmiBlocks for?<\/h2>\n\n\n\n

AmiBlocks seems particularly attractive to three groups. The first is the returning Amiga programmer who remembers enough C to be dangerous but has absolutely no desire to spend the first weekend reconstructing a 1990s development setup.<\/p>\n\n\n\n

The second is the enthusiast who deliberately wants a self-contained native environment. Perhaps there is a PiStorm or accelerator involved, perhaps there is an unnecessarily magnificent RTG Workbench, and perhaps the entire point is to see just how productive a classic Amiga can still be.<\/p>\n\n\n\n

The third, and potentially most important, is the curious programmer who has always wanted to write Amiga software but found the traditional toolchain unnecessarily intimidating. Lowering that barrier matters.<\/p>\n\n\n\n

New Amiga software ultimately depends on people deciding that making something for an Amiga sounds like fun. Every hour spent configuring makefiles, chasing compiler packages and assembling development utilities is an opportunity for that person to decide that perhaps playing Sensible World of Soccer<\/em> would be easier. AmiBlocks wants the first experience to be creating a project and typing code instead. That is a much better invitation.<\/p>\n\n\n\n

A modern idea running on an old machine<\/h2>\n\n\n\n

There is a temptation in retrocomputing to preserve old computers as though they were museum exhibits. Install the software that existed in 1992. Play the games that existed in 1992. Recreate the desktop you had in 1992. Then carefully avoid doing anything that somebody could not have done in 1992. The Amiga scene has rarely been particularly good at obeying that rule, thankfully.<\/p>\n\n\n

\n
\"Three-panel<\/picture>
AmiBlocks and AmiCC23 aim to make native Amiga development feel modern again, combining coding, compiling and debugging in one integrated environment.<\/figcaption><\/figure>\n<\/div>\n\n\n

AmiBlocks and AmiCC23 fit into the more interesting tradition: take the old machine seriously enough to keep developing for it<\/strong>. The IDE borrows expectations from contemporary development environments. The compiler aims at a language standard published decades after Commodore disappeared. The resulting programs still run as native Amiga executables. There is something wonderfully backwards about that. Or perhaps wonderfully forwards.<\/p>\n\n\n\n

AmiBlocks is not finished, AmiCC23 still has a lot to prove, and anyone expecting the polish and exhaustive tooling of a mainstream IDE needs to remember the scale of the project and the platform involved. But the concept is excellent. The Amiga does not particularly need another way of becoming a target attached to a powerful PC. We already have very good ones. What it has been missing is a genuinely modern attempt to make developing on the Amiga itself<\/strong> pleasant again. AmiBlocks may be the most interesting attempt at that in quite some time.<\/p>\n\n\n\n

And if AmiCC23 develops into a genuinely capable C23 compiler along the way, the small IDE that appeared on Aminet this summer could turn out to have been only the beginning.<\/p>\n\n\n\n

Visit the project page<\/a><\/p>\n\n\n\n

<\/p>\n","protected":false},"excerpt":{"rendered":"

AmiBlocks and AmiCC23 bring modern C development back to AmigaOS, combining coding, compiling and debugging in one native environment and making the Amiga a development machine again.<\/p>\n","protected":false},"author":1,"featured_media":2669,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[12,19],"tags":[501,492,493,16,494,504,503,17,495,496,214,507,500,506,499,502,505,498,198,497],"class_list":["post-2668","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-development","category-retrocomputing","tag-68k","tag-amiblocks","tag-amicc23","tag-amiga","tag-amiga-development","tag-amiga-programming","tag-amiga-software","tag-amigaos","tag-c-programming","tag-c23","tag-classic-computing","tag-coding","tag-compiler","tag-development-tools","tag-ide","tag-motorola-68000","tag-native-development","tag-programming","tag-retrocomputing","tag-software-development"],"_links":{"self":[{"href":"https:\/\/alterego.cc\/wp\/wp-json\/wp\/v2\/posts\/2668","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/alterego.cc\/wp\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/alterego.cc\/wp\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/alterego.cc\/wp\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/alterego.cc\/wp\/wp-json\/wp\/v2\/comments?post=2668"}],"version-history":[{"count":4,"href":"https:\/\/alterego.cc\/wp\/wp-json\/wp\/v2\/posts\/2668\/revisions"}],"predecessor-version":[{"id":2676,"href":"https:\/\/alterego.cc\/wp\/wp-json\/wp\/v2\/posts\/2668\/revisions\/2676"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/alterego.cc\/wp\/wp-json\/wp\/v2\/media\/2669"}],"wp:attachment":[{"href":"https:\/\/alterego.cc\/wp\/wp-json\/wp\/v2\/media?parent=2668"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/alterego.cc\/wp\/wp-json\/wp\/v2\/categories?post=2668"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/alterego.cc\/wp\/wp-json\/wp\/v2\/tags?post=2668"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}