Installation

AuraBoot can be evaluated with Docker Compose or run manually for development. Docker is the recommended path for first-time users because it keeps PostgreSQL, Redis, backend, and frontend versions aligned.

Prerequisites

Option A: Docker Compose

Clone the repository:

git clone https://github.com/AuraBootTeam/auraboot.git
cd auraboot

Start the full stack:

docker compose --profile full up --build -d

Check service status:

docker compose ps

Expected local endpoints:

Redis is not started by --profile full — it lives in the cache profile, and you do not need it to evaluate AuraBoot.

Open the frontend and log in with the local admin account:

Run from prebuilt images

To just run AuraBoot without building from source, pull the prebuilt images instead — this skips the Java + Node build entirely. Everything a first boot needs is baked into the images (database schema, backend plugins), so you need no git clone — just two files:

curl -O https://raw.githubusercontent.com/AuraBootTeam/auraboot/main/docker-compose.pull.yml
curl -O https://raw.githubusercontent.com/AuraBootTeam/auraboot/main/scripts/quickstart.sh
docker compose -f docker-compose.pull.yml up -d
bash quickstart.sh

Then open http://localhost:3000 and log in with admin@auraboot.com / Test2026x.

The images are multi-arch (amd64 / arm64) and published to GitHub Container Registry:

Mainland China — pull from the Tencent Cloud (TCR) mirror instead; it is much faster than GHCR:

REGISTRY=ccr.ccs.tencentyun.com/auraboot-oss docker compose -f docker-compose.pull.yml up -d

Windows deployment

AuraBoot runs on Windows through Docker Desktop (WSL2 backend). Every docker compose command on this page works unchanged — the only rule is that the bash scripts (quickstart.sh and the other scripts/*.sh) must run from a WSL shell or Git Bash, never PowerShell or cmd. Follow these steps.

1. Install Docker Desktop with the WSL2 backend

Install Docker Desktop and, under Settings → General, keep "Use the WSL 2 based engine" enabled (it is on by default). Start Docker Desktop and wait until the engine reports Running.

2. Get a bash shell

quickstart.sh and the other scripts/*.sh are bash scripts — PowerShell and cmd cannot run them. Use either:

• WSL (recommended): open PowerShell as Administrator, run wsl --install, reboot, then open the Ubuntu terminal.
• Git Bash: install Git for Windows; it ships with Git Bash.

Run every command below inside that WSL or Git Bash window, not PowerShell.

3. Start AuraBoot

From prebuilt images (recommended — no build, no clone):

curl -O https://raw.githubusercontent.com/AuraBootTeam/auraboot/main/docker-compose.pull.yml
curl -O https://raw.githubusercontent.com/AuraBootTeam/auraboot/main/scripts/quickstart.sh
docker compose -f docker-compose.pull.yml up -d
bash quickstart.sh

In mainland China, prefix the up command with REGISTRY=ccr.ccs.tencentyun.com/auraboot-oss to pull from the Tencent Cloud mirror (see the previous section).

Or from source (if you want to build it yourself):

git clone https://github.com/AuraBootTeam/auraboot.git
cd auraboot
docker compose --profile full up --build -d
bash scripts/quickstart.sh

quickstart.sh is not optional — it creates the admin user and imports the plugins.

4. Open the app

start http://localhost:3000

(start is the Windows equivalent of macOS's open.) Log in with admin@auraboot.com / Test2026x, then change the password.

Native, non-Docker Windows deployment is not supported. The reset / init / build tooling is bash-only and the repo ships no gradlew.bat — always use the Docker Desktop path above.

Option B: Manual development setup

Manual setup is useful when you are changing backend or frontend code and want hot reload.

1. Create the database

createdb -U postgres aura_boot

Use PostgreSQL 16 or later. The dynamic model runtime creates metadata and business tables during bootstrap and plugin import.

2. Start Redis

redis-server

3. Start the backend

cd platform
cp src/main/resources/application-local.yml.example src/main/resources/application-local.yml
./gradlew bootRun

Update application-local.yml with your PostgreSQL and Redis connection values before starting the backend.

4. Start the frontend

cd web-admin
pnpm install
pnpm dev:full

The frontend development server and BFF layer run together. The BFF proxies browser requests to the backend and keeps local development close to production behavior.

5. Bootstrap the platform

If your local scripts do not bootstrap automatically, create the first tenant and admin user:

./scripts/quickstart.sh

docker compose up starts the services and nothing else — it creates no admin user and imports no plugins. This script does both, and is idempotent.

Verify installation

Check backend health:

curl http://localhost:3000/api/bootstrap/status

Expected response:

{
  "data": { "initialized": true }
}

Check CLI connectivity:

aura status

Check the browser:

1. Open http://localhost:3000.
2. Log in as the admin user.
3. Confirm menus render.
4. Open a generated list page or plugin page.

Troubleshooting

For deeper local development, use CLI and Plugin Development.