The vision

After using a lot of different software Directus was my first choice for any of my projects. They had a clean UI, good system and good support, however they made decisions that i personally don’t agree with (in short: moved to a different license, dropped the Discord support, did not complete features).

Therefore, I decided that it was time to start experimenting with making a new system. The idea is very simple:

• Be transparent
• Anything that can be done in the UI should be doable in the UI
• Simple, if you don’t understand the backend, you should still be able to manage a project
• Extensible, plugins should not be bound to any language
• Lightweight, why use a lot of resources when you don’t need them? ;)
• Easy to develop

Most of my inspiration is taken from Directus, Railway, Zoho and Wordpress.

Transparency

I dislike projects that are not transparent or that are getting absorbed by investors. Therefore the licensing pricing is already public and the repository can be found on GitHub.

Since this is my first project of this scale, it will probably take some time to get the communication right. For now, I see the Discord server as the easiest way to keep in touch. However, if you need to report a bug or have a feature request, feel free to use GitHub!

UI

At the time of writing the UI is capable of:

• Managing the database (creating collections/fields)
• Managing permissions (deciding who sees what)
• Supporting multiple roles (what menu`s, records, fields etc. a user can see)
• Allow you to easily install/manage plugins

Simple

Everyone can understand dragging and menu`s. Whever possible AlcedoCore provides this. No need to touch any code!

Extensible/plugins

For plugins I have decided to work with a “flexible” concept based on Docker Swarm. When you require a backend plugin, you can install it through the UI. In the background a Docker container will be spawned and it will serve any requests behind AlcedoCore. The way this is set up allows to add adapters for allowing multiple platforms (for example Kubernetes, Railway or others). You could see AlcedoCore as a reverse proxy for plugins.

Lightweight

The backend will be running in Rust. The frontend (the admin plugin) is running purely client-side in Vue.js.

This results in AlcedoCore using around 13MB*. For context, one of the Directus instances that I am running is using around 170 MB (approximately 13 times more).

The only tradeoff that AlcedoCore has (because of the plugin system) is that every single backend plugin will run its own container, which can of course result in more memory usage.

Easy to develop

For starters there is a Docker Compose generator available. Using this you can have AlcedoCore up and running within a minute.

CLI

Any platform like this needs a proper CLI. Here is a short tour of how to develop a plugin:

1. Install the AlcedoCore CLI (npm i -g @AlcedoCore/cli)
2. Generate a plugin setup (alcedo init {name}) and choose Node.js or Python
3. Open a terminal in the generated plugin
4. Connect to your AlcedoCore instance (alcedo connect)

Then these commands can be used:

• alcedo publish: this will build and push the plugin to the plugin registry
• alcedo dev proxy: starts a proxy that can be used for (live) development
• alcedo dev serve-frontend: runs the frontend so that you can use development mode
• alcedo dev build-frontend: build the frontend so that it can be published There are other commands included in the current CLI but these are probably going to change or get removed soon

AI

Using the development of prototypes and the current release I have used AI. When i released the code publicly (July 16, 2026) 99% of the whole project was vibe-coded. But since then I have been cleaning up the code, making proper use of what Vue/Rust have to offer.

Current state

As the title suggests, AlcedoCore release candidate 1 is out. It should give you a clear idea of how the platform will work. This release will probably include bugs or features that are not fully developed yet. The following features are currently included:

• Data modeling
• Custom views
• Create/update/delete/view data
• Permissions & Authentication
• Record filtering
• Plugin management (including scaling/upgrading)
• File uploads
• CLI (based on Typescript)
• SDK (Typescript)

What is next

For this release candidate I have gone through the whole admin plugin and cleaned it up. However, the Rust code still needs attention. This will be my primary goal. During this time i will also take a look at some of the known backend bugs. Meanwhile i will also be adding more documentation about the concepts of AlcedoCore.

What is on my mind

• CLI commands, which ones do we need and how far should it go?
• The core as registry proxy, currently the CLI expects a direct connection to the system registry (internal registry for plugins). It would be nice if this were proxied so that we can check if the requester is actually authenticated etc.
• Rust & Python plugin SDKs, we currently have these already but they are not tested

Roadmap

Currently we have the following priority of the roadmap*:

• Cleanup of the backend (in the works right now)
• (plugin) SDKs in Rust & Python: We already have these but they have not been tested yet
• Multi-app support
• Version management
• Database Introspection
• Import / Export

Any of the other roadmap items and its status can be found here.

* At the time of writing this article