Squidex's Dockerfile runs the .NET test suite before it publishes the backend
Headless CMS and Content Managment Hub
At a glance
- What is it?
- Squidex is an MIT headless CMS on ASP.NET Core with an OData-filtered API and a UI you are meant to supply yourself, yet the repository ships a frontend build stage. The deployment table names nine platforms, and two of them deploy from files that live outside this repository.
- Who is it for?
- Squidex fits teams that want an API-first CMS with OData filtering and Swagger definitions, and that are willing to choose and run the database and asset storage themselves. It does not fit anyone expecting a described admin interface, because the repository ships a compiled frontend bundle without saying what is in it.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository received new commits within the last day.
- What is it written in?
- Mainly C#, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- Squidex/squidex2,517 ★ · +10
| Repository | 2026-09-30 | 2026-11-15 |
|---|---|---|
| Squidex/squidex | 2.5k | 2.5k |
10 Stars in the last 46 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
Nine platforms, two of them reached through other repositories
The deployment table names nine targets: Azure, AWS, Docker, GCP, Heroku, IIS, K8S, Render and Vultr. Only four rows fill the Quicklink column. The Docker link is not a file in this repository, it opens a compose file inside the squidex-hosting repository. The Azure link is a raw.githubusercontent.com address pointing into sangramrath/squidex-docs2 on branch master, a documentation fork under a maintainer's own account, so the one-click ARM template is not versioned next to the CMS source and a reviewer looking at a change under backend/ never sees it. AWS, GCP, IIS and K8S have documentation links and nothing else. Four targets do have in-tree descriptors: app.json and heroku.yml for Heroku, render.yaml for Render, and a helm/ directory for Kubernetes, which is the one platform whose row carries no quicklink even though a chart sits in the tree. The practical difference between the two groups is narrow: the Heroku and Render paths are pinned to code you can read in the tree, while the Azure and Docker paths follow whatever those other repositories hold today.
The build image pins the .NET 10 SDK while the prerequisites ask for .NET 8
The backend stage opens on `FROM --platform=$BUILDPLATFORM mcr.microsoft.com/dotnet/sdk:10.0 AS backend`, and the prerequisites list ends with the .NET 8 SDK, noted as already part of Visual Studio 2022 v17.8. A contributor who installs what the list says gets 8, and the image that gets built uses 10. Nothing in the repository states which target framework the sources compile against, so the gap is visible only by reading both places and noticing they disagree. The same line pins the compile stage to $BUILDPLATFORM, the architecture of the machine running the build rather than the target architecture, which leaves the runtime stage as the place where the shipped architecture is settled. Node.js appears in the prerequisites as development only, and yet the second stage runs a full npm install, lint, coverage run and production build inside the image on a base tagged squidex/frontend-build:22.19. That image build is the one place in the repository where all four of those steps run together.
The README hands you the UI, and the image build compiles one anyway
The opening paragraph says Squidex provides a rich API with OData filter and Swagger definitions, and that it is up to you to build your UI on top of it, whether that turns out to be a website, a native app or just another server. The tree disagrees in a way that matters at image build time. There is a frontend/ directory, and the second Dockerfile stage copies frontend/package*.json, installs dependencies, lints, measures coverage, builds, and finishes with `cp -a build /build/`. That last line drops a compiled asset bundle into the same /build directory the backend was published into one stage earlier, so a self-hosted image is not a bare API surface. Nothing in the repository says what the bundle contains, whether it is required, or whether it can be skipped. The documentation site the README points readers to, docs.squidex.io, carries the annotation work in progress, so the answer is not there either.
The build arguments default to 7.0.0 and one of them is echoed into the log
The backend stage takes the version from `ARG SQUIDEX__BUILD__VERSION=7.0.0` and passes it to the publish step as `-p:version=$SQUIDEX__BUILD__VERSION`, so an image built without that argument stamps its binaries as 7.0.0, twenty-four minor releases behind the newest tag, 7.24.0 from 28 September 2026. The same gap shows in prose. Under Status the text reads Current Version and then jumps straight to a Trello roadmap link, with no version after the label. Tag dates are uneven too: 7.22.0 and 7.23.0 arrived two days apart in April 2026, then more than five months passed before 7.24.0, while the default branch master received a push on 2 October 2026, days after that tag. The second argument needs care. `RUN echo "ARGS IS $SQUIDEX__BUILD__ARGS"` prints whatever was passed to it, and the same value is then expanded unquoted into the publish command line, which the layer records verbatim. Anything a pipeline passes there, a private feed token or a signing parameter, lands in the build log and in the image history, where anyone who can pull the image can read it.
Every csproj has to sit exactly one level under backend/src
The backend stage restores packages before it copies any source, and it does it with a shell loop after each glob:
COPY backend/src/*/*.csproj ./
RUN for file in $(ls *.csproj); \
do mkdir -p src/${file%.*}/ && mv $file src/${file%.*}/; \
doneThe same three lines are repeated for backend/tests and backend/extensions, which gives the restore layer the shape the source tree had at one level less. Two constraints follow, and neither is written down in prose anywhere. A project file nested more deeply, for instance backend/src/Group/Service/Service.csproj, is not matched by the glob at all, so it never reaches the restore layer and dotnet restore runs without it. And because each directory is regenerated from the file stem, a project whose folder name and csproj name differ is restored under the stem, which is the path the publish step later walks when it is pointed at src/Squidex/Squidex.csproj. Moving a project one directory deeper is therefore a change that breaks the image build before any code runs.
The image cannot be built unless the test suite passes
Between the restore and the publish, the Dockerfile runs:
RUN dotnet test --filter "Category!=Dependencies & Category!=TestContainer" --configuration ReleaseThe image build is therefore gated on the whole unit suite, and the two categories excluded are the ones that would need a database or a container. That split lines up with the prerequisites, which name MongoDB, PostgreSQL, MySQL or SQLServer as things a human setup needs while an image build needs none of them. ffmpeg is installed into the same stage under the comment FFMPEG for tests, so media handling is part of what a build has to get through before it publishes anything. The stage also installs two diagnostics tools with `dotnet tool install --tool-path /tools`: dotnet-dump and dotnet-gcdump. Whether those tools and the /build output are carried into the shipped image is settled by the third stage, labelled Build runtime, whose first line reads `FROM mcr.microsoft.com/` and stops there, with the image name and every instruction after it left unwritten.
npm install --force replaces peer dependency errors with whatever resolves
The frontend stage sets CONTINUOUS_INTEGRATION=1, copies only package*.json, runs `npm install --loglevel=error --force`, copies the rest of frontend/, and then runs npm run lint, npm run test:coverage and npm run build as one chained layer before copying the output. The flag is what makes that stage hard to reproduce outside Docker: with --force npm stops enforcing peer dependency version ranges, so a clean checkout can fail at npm install on a peer conflict that the image build waves through, and the first visible failure moves later in the pipeline, to lint or to the coverage threshold. The command is npm install and not npm ci, so the dependency tree is resolved again inside the image instead of replayed from a committed lockfile. Chaining lint, coverage and build into a single layer has a second effect worth knowing: a coverage regression stops the layer before npm run build runs, and the published bundle that stage produces is all or nothing rather than a partial artifact.
One core maintainer, and the asset stores that came from outside
Under Core Team and Founders the README lists exactly one person, Sebastian Stehle, a software engineer in Germany. The contributor list below him names the feature each party added, and read together it maps the storage and rule surface: civicplus added Google Maps support and custom regex patterns, cpmstars added asset support for the rich editor, guohai added an FTP asset store and email rule support, pushrbx added Azure Store support, razims added GridFS support, and sauravvijay added a Kafka rule action. GridFS and Azure Store matter because the prerequisites name four databases and no asset store at all, so the asset layer is assembled from outside contributions rather than from one built-in choice. The rest of the tree is deployment and tooling rather than application code: app.json, heroku.yml, render.yaml, helm/, packer/, dev/, tools/, an sdk/ directory, two local build entry points in build.sh and build.ps1, plus CLAUDE.md and todo.md at the root. Alongside the self-hosted product the project runs a hosted version at cloud.squidex.io.
Editorial conclusion
Squidex fits teams that want an API-first CMS with OData filtering and Swagger definitions, and that are willing to choose and run the database and asset storage themselves. It does not fit anyone expecting a described admin interface, because the repository ships a compiled frontend bundle without saying what is in it. Before adopting it, check three things: which build arguments your pipeline passes, since the Dockerfile falls back to version 7.0.0 and echoes one argument value into the build log; which .NET version contributors actually have, since the prerequisites say 8 and the build image says 10; and whether the Azure and Docker files you plan to start from still match the branch you are reading, since both sit outside this repository. The code is MIT, so licensing imposes no obstacle.
Frequently asked questions
What is PO Squidex CMS?
The README never spells out the abbreviation PO, so that part of the name has no answer in the repository. What it does define is Squidex as an open source headless CMS and content management hub, built with ASP.NET Core and CQRS, licensed MIT, exposing a rich API with OData filter and Swagger definitions that you build a UI on top of.
squidex vs strapi
The repository says nothing about Strapi, so that comparison cannot be settled from Squidex itself. Squidex describes itself as a headless CMS with an OData-filtered API, deployable to the nine platforms in its table, licensed MIT, with a hosted version at cloud.squidex.io. Run your own evaluation for the rest.
Which databases and asset stores can Squidex use?
The prerequisites list MongoDB, PostgreSQL, MySQL and SQLServer, and it names no asset store at all. Asset storage appears only in the contributor list: GridFS support contributed by razims, Azure Store support by pushrbx, an FTP asset store by guohai, and asset support for the rich editor by cpmstars.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/squidex-squidex)Star history chart for your README
[](https://hysenlabs.com/projects/squidex-squidex)Was this useful?