Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/Fixius50/WorlBuilding-Writting-App/llms.txt

Use this file to discover all available pages before exploring further.

The Chronos Atlas auxiliary backend is a locally-run Java process that acts as a file system bridge between the browser-sandboxed frontend and the real operating system disk. Because the browser cannot write arbitrary files to user-chosen paths, the Java server fills that role: it receives data from the frontend over HTTP, performs disk I/O, and returns results as downloadable streams. It also handles computationally expensive tasks — document compilation, font rendering, and image processing — that are impractical to run inside the browser.
The auxiliary backend is entirely optional for core worldbuilding tasks. Writing, editing entities, managing timelines, and working with the graph all function without it. The backend is required only for: SQLite backup/restore to disk, map asset upload and download, world bible export (EPUB/PDF/DOCX/HTML), and conlang font compilation (.ttf).

​
Technology Stack

ComponentTechnologyVersion
LanguageJava21
Web FrameworkSpring Web MVC5.3.31
Embedded ServerEclipse Jetty9.4.58.v20250814
JSON SerialisationJackson Databind2.15.2
UtilitiesProject Lombok1.18.30
LoggingSLF4J + Logback1.7.36 / 1.2.13
PDF RenderingFlying Saucer (openpdf)9.1.22
HTML Parsingjsoup1.17.2
BuildMaven Shade Plugin3.5.1 (fat JAR)
The server is packaged as a self-contained fat JAR via the Maven Shade plugin and starts on port 8080 by default. The Vite dev server proxies all /api/* requests to http://localhost:8080 during development.

​
Domain Structure

The backend follows a domain-driven package layout under com.worldbuilding. The Spring context is bootstrapped by AuxServerApplication with a component scan over both com.worldbuilding.core and com.worldbuilding.domains: 
com.worldbuilding
├── core/
│   ├── AuxServerApplication.java     # Jetty bootstrap, Spring context, CORS filter
│   └── controller/
│       ├── DatabaseController.java   # /db — backup, restore, ZIP export/import
│       ├── SyncController.java       # /sync — JSON payload archiving
│       ├── EditorExportController.java # /editor — HTML-to-PDF export
│       └── SystemController.java     # /system — health check, ping
└── domains/
    ├── mapeditor/
    │   ├── controller/MapEditorController.java   # /mapeditor — asset upload/download
    │   ├── model/MapAsset.java
    │   └── service/MapAssetProcessor.java
    ├── worldbible/
    │   ├── controller/WorldBibleExportController.java  # /worldbible — book compilation
    │   ├── model/CompilationSettings.java
    │   ├── model/ExportFormat.java
    │   └── service/BookCompilerService.java
    └── linguistics/
        ├── controller/LinguisticsFontController.java  # /linguistics — font compile
        ├── model/ConlangGlyph.java
        ├── model/FontConfig.java
        └── service/FontCompilerService.java

core controllers

Handle database lifecycle (backup/restore/ZIP), JSON sync archiving, HTML-to-PDF export, and system health.

domains.mapeditor

Upload and serve map images; create blank PNG canvases. Assets stored in maps_assets/.

domains.worldbible

Compile a project’s world bible content tree into EPUB, PDF, DOCX, or offline HTML.

domains.linguistics

Accept SVG glyph paths + font metadata and return a compiled TrueType .ttf font file.

​
CORS and Isolation Headers

The Jetty bootstrap filter sets the following response headers globally for all requests: 
Access-Control-Allow-Origin: *
Access-Control-Allow-Methods: POST, GET, OPTIONS, DELETE, PUT
Access-Control-Allow-Headers: x-requested-with, authorization, Content-Type, Authorization, credential, X-XSRF-TOKEN
HTTP OPTIONS preflight requests are intercepted and answered with 200 OK immediately, before the Spring dispatcher runs. The filter also sets isolation headers required by SQLite WASM: 
Cross-Origin-Opener-Policy: same-origin
Cross-Origin-Embedder-Policy: credentialless

​
Running the Backend

1

Windows — run-app.bat (recommended)

From the project root, execute the provided batch script. It launches both the Java backend and the Vite frontend in a single command:
run-app.bat
2

Manual — Maven from /backend

Navigate to the backend/ directory, build the fat JAR, and run it directly:
cd backend
mvn package -q
java -jar target/aux-server-1.0.0.jar
The server prints Server started at http://localhost:8080 when ready.
The backend also serves the Vite production build as static files from ./dist when running in production mode. During development, the Vite dev server on port 5173 proxies /api/* to the backend on port 8080.

​
File Storage

The backend stores files relative to the working directory from which the JAR is launched:
DirectoryContents
backup/Project .sqlite database backups and .sync.json payload archives
maps_assets/Map image assets — named {projectName}_{fileName}
Both directories are created automatically on startup if they do not exist. There is no configuration file; the working directory is the implicit root.

​
System Endpoints

Two lightweight system endpoints are available on the core controllers for health checks: 
# Returns JSON: { active, version, runtime, framework }
curl http://localhost:8080/api/system/status

# Returns plain text: "pong"
curl http://localhost:8080/api/system/ping

Build docs developers (and LLMs) love

Get started for freeTalk to us