CodeZero publishes new canary release with AI flow generation

Nico Sammito — Sat, 04 Jul 2026 12:23:56 +0000

Explore the latest CodeZero canary release featuring AI-powered flow generation, a brand-new module system, and a new execution results view in the IDE.

We are excited to announce the release of our latest canary version, one of the biggest steps in the development of CodeZero so far. This update brings artificial intelligence into the platform for the first time, introduces a completely new module system, and gives you full insight into your flow runs with a new execution results view in the IDE.

Build flows with AI

CodeZero can now generate flows for you. Simply describe what your automation should do, pick one of the available AI models, and watch your flow being built in real time. This is the first milestone on our journey to make backend automation accessible to everyone, whether you prefer building visually or simply describing your idea in plain language.

A smarter way to organize: modules

With this release, the entire platform has been restructured around modules. Functions, flow types, and data types are now neatly bundled and delivered as modules, making it much clearer which capabilities are available in your project at any time. You can see all available modules at a glance, configure them individually for each project, and when adding a new step to a flow, suggestions are now conveniently grouped by module. The result is a tidier, more intuitive building experience that scales with your projects.

Execution results at a glance

Understanding what your flows are doing just got a lot easier. The IDE now features a new execution results view that shows you the outcome of every run, step by step, so finding and fixing problems takes seconds instead of guesswork. Results are saved as well, letting you revisit previous runs whenever you need them. Behind the scenes, this release also lays the complete groundwork for test executions, so soon you will be able to start test runs directly from the IDE.

A better building experience

The IDE has received plenty of love in this release. New input fields for text, numbers, toggles, and selections make configuring your flows easier than ever, and the reworked suggestion menu with tabs and search helps you find the right building block in an instant. On top of that, a new license management page gives self-managed installations a simple way to handle their Enterprise Edition licenses.

More stability under the hood

As always, a large part of our work went into making the platform more reliable. Runtimes now report their health continuously, so unresponsive services are detected immediately. Connecting external services has become more secure with new authentication options, and countless fixes and refinements across all components make this our most stable canary version yet.

Credits and Documentation

This release was made possible by the dedicated efforts of our contributors. We would like to thank everyone who contributed to this canary version:

Niklas van Schrick
Raphael Arun Götz
Nicolas Morawietz
Dario Pranjić
Marius Ahsmus
Nico Sammito

For those who want to dive deeper into the technical details or start testing the latest build, our documentation provides all the necessary resources:

Detailed Changes: For a full list of all technical modifications and updates, visit our Changelog.
Getting Started: Step-by-step instructions for setting up the latest version can be found in our Installation Guide.

Ongoing development status

CodeZero is still in active development, and this canary release lays the foundation for everything that comes next. With AI flow generation, the new module system, and the execution results view now in place, we are closer than ever to a complete platform. Our focus now shifts to polishing these features and making the building experience even smoother.

CodeZero is 30x times faster than n8n

Nico Sammito — Thu, 16 Apr 2026 13:56:37 +0000

The biggest lie in the software industry is that no-code has to be slow. For years, developers and enterprises have paid a “no-code tax,” trading performance for ease of use. At CodeZero, we decided to kill that trade-off.

To prove it, we staged a battle against n8n, the current industry standard. We didn’t use theoretical models. We used an Apple M3 MacBook Air and identical workflows on both platforms. The result is that CodeZero isn’t just an alternative, it’s a generational leap in efficiency.

The setup: identical logic, no excuses

A benchmark is only as good as its transparency. We mirrored the exact same logic on both platforms: a simple HTTP webhook that returns a 200 OK response. By removing external variables like API delays or database latency, we isolated the raw overhead of the execution engines themselves.

Using Docker, we capped resources at three tiers (1.0, 0.5, and 0.25 vCPU) and used k6 to simulate high-concurrency traffic.

1.0 vCPU: 12x more throughput

Even when given a full core, legacy architecture hits a wall. While n8n struggles to manage its own internal processes, CodeZero focuses entirely on moving data.

The data shows that CodeZero scaled effortlessly to 2,147 req/s, while n8n peaked at a mere 177 req/s. This gap represents the difference between a system that thrives under pressure and one that merely survives.

At 200 concurrent users, n8n delayed for 1.1s while CodeZero stayed at 0.1s. In a production environment, this means you can handle an entire marketing spike on a single core that would have crashed a legacy setup. CodeZero is 11x faster out of the gate.

0.5 vCPU: 20x higher efficiency

Most cloud instances run on limited resources to save costs. This is where CodeZero’s lean architecture turns into a massive financial advantage for any business scaling its automation.

In this mid-tier setup, CodeZero maintained a rock-solid 1,279 req/s. In contrast, n8n’s throughput dropped to 64 req/s. The efficiency multiplier here is 20x, meaning your hardware is significantly more productive with CodeZero.

This is where it gets dangerous for legacy systems. The response times for n8n spiked to 3.0s, which is unacceptable for modern real-time applications. CodeZero held steady at 0.2s, ensuring that the end-user never feels the load.

0.25 vCPU: the 17-second collapse

We pushed both engines into a resource-starved environment to see which one would break first. The results were staggering and highlight the fundamental architectural differences.

Under extreme pressure, n8n gasped for air at 10 req/s. CodeZero still pushed a functional 339 req/s. This proves that CodeZero can handle significant traffic even on the cheapest possible entry-level hardware.

The latency results here are the final breaking point. n8n exploded to 17.6s, which is effectively a total system failure. CodeZero finished the same task in 0.6s. CodeZero is 29.3x faster when resources are tight, keeping the lights on while others fail.

Why the gap is so large

Since the workflows were identical, this isn’t about the complexity of the tasks. It is about the platform itself. We used Rust to develop the execution layer where n8n uses Node.

No-code is officially fast. Welcome to the future of execution.

DEV Community: Nico Sammito