titanpl 26.17.0 → 26.17.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "titanpl",
-  "version": "26.17.0",
+  "version": "26.17.2",
   "description": "Titan Planet is a JavaScript-first backend framework that embeds JS actions into a Rust + Axum server and ships as a single native binary. Routes are compiled to static metadata; only actions run in the embedded JS runtime. No Node.js. No event loop in production.",
   "license": "ISC",
   "author": "ezetgalaxy",
@@ -16,6 +16,7 @@
   ],
   "files": [
     "index.js",
+    "packages/",
     "templates/",
     "titanpl-sdk",
     "README.md"
@@ -69,8 +70,8 @@
     "test:all": "vitest run && vitest run --config vitest.config.e2e.ts"
   },
   "dependencies": {
-    "@titanpl/core": "latest",
-    "@titanpl/node": "latest",
+    "@titanpl/core": "26.17.1",
+    "@titanpl/node": "26.17.1",
     "chokidar": "^5.0.0",
     "esbuild": "^0.27.2",
     "prompts": "^2.4.2"

package/packages/cli/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@titanpl/cli",
+  "version": "26.17.2",
+  "description": "The unified CLI for Titan Planet. Use it to create, manage, build, and deploy high-performance backend projects.",
+  "keywords": [
+    "titanpl",
+    "titan",
+    "ezetgalaxy",
+    "cli"
+  ],
+  "license": "ISC",
+  "author": "ezetgalaxy",
+  "type": "module",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "bin": {
+    "titan": "./index.js"
+  },
+  "optionalDependencies": {
+    "@titanpl/engine-win32-x64": "26.17.2",
+    "@titanpl/engine-linux-x64": "26.17.2",
+    "@titanpl/engine-darwin-arm64": "26.17.2"
+  },
+  "dependencies": {
+    "@titanpl/packet": "26.17.2",
+    "prompts": "^2.4.2",
+    "commander": "^11.0.0",
+    "chalk": "^4.1.2"
+  }
+}

package/packages/cli/src/commands/build.js

@@ -0,0 +1,6 @@
+import { build } from "@titanpl/packet";
+
+export async function buildCommand() {
+  const dist = await build(process.cwd());
+  console.log("✔ Build complete →", dist);
+}

package/packages/cli/src/commands/dev.js

@@ -0,0 +1,7 @@
+import { dev } from "@titanpl/packet";
+import { startEngine } from "../engine.js";
+
+export async function devCommand() {
+  await dev(process.cwd());
+  startEngine(true);
+}

package/packages/cli/src/commands/init.js

@@ -0,0 +1,163 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { spawn } from 'child_process';
+import prompts from 'prompts';
+import chalk from 'chalk';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export function copyDir(src, dest, excludes = []) {
+    fs.mkdirSync(dest, { recursive: true });
+
+    for (const file of fs.readdirSync(src)) {
+        if (excludes.includes(file)) continue;
+
+        const srcPath = path.join(src, file);
+        const destPath = path.join(dest, file);
+
+        if (fs.lstatSync(srcPath).isDirectory()) {
+            copyDir(srcPath, destPath, excludes);
+        } else {
+            fs.copyFileSync(srcPath, destPath);
+        }
+    }
+}
+
+export async function initCommand(projectName, templateName) {
+    let projName = projectName;
+
+    if (!projName) {
+        const res = await prompts({
+            type: 'text',
+            name: 'name',
+            message: 'Project name:',
+            initial: 'my-titan-app'
+        });
+        projName = res.name;
+    }
+
+    if (!projName) {
+        console.log(chalk.red("✖ Initialization cancelled."));
+        process.exit(1);
+    }
+
+    let selectedTemplate = templateName;
+
+    if (!selectedTemplate) {
+        const langRes = await prompts({
+            type: 'select',
+            name: 'value',
+            message: 'Select language:',
+            choices: [
+                { title: 'JavaScript', value: 'js' },
+                { title: 'TypeScript', value: 'ts' },
+            ],
+            initial: 0
+        });
+
+        if (!langRes.value) {
+            console.log(chalk.red("✖ Operation cancelled."));
+            process.exit(1);
+        }
+        const lang = langRes.value;
+
+        const archRes = await prompts({
+            type: 'select',
+            name: 'value',
+            message: 'Select template:',
+            choices: [
+                {
+                    title: `Standard (${lang.toUpperCase()})`,
+                    description: `Standard Titan app with ${lang.toUpperCase()} actions`,
+                    value: 'standard'
+                },
+                {
+                    title: `Rust + ${lang.toUpperCase()} (Hybrid)`,
+                    description: `High-performance Rust actions + ${lang.toUpperCase()} flexibility`,
+                    value: 'hybrid'
+                }
+            ],
+            initial: 0
+        });
+
+        if (!archRes.value) {
+            console.log(chalk.red("✖ Operation cancelled."));
+            process.exit(1);
+        }
+        const arch = archRes.value;
+
+        if (lang === 'js') {
+            selectedTemplate = arch === 'standard' ? 'js' : 'rust-js';
+        } else {
+            selectedTemplate = arch === 'standard' ? 'ts' : 'rust-ts';
+        }
+    }
+
+    const target = path.resolve(process.cwd(), projName);
+    const templateDir = path.resolve(__dirname, '..', '..', '..', '..', 'templates', selectedTemplate);
+    const commonDir = path.resolve(__dirname, '..', '..', '..', '..', 'templates', 'common');
+
+    if (!fs.existsSync(templateDir) || !fs.existsSync(commonDir)) {
+        console.log(chalk.red(`✖ Error finding template paths.Are you in a valid Titan monorepo ? `));
+        process.exit(1);
+    }
+
+    if (fs.existsSync(target)) {
+        console.log(chalk.red(`✖ Directory '${projName}' already exists.`));
+        process.exit(1);
+    }
+
+    console.log(chalk.cyan(`\n→ Creating new Titan project in '${projName}'...\n`));
+
+    // 1. Copy common
+    copyDir(commonDir, target, ["_gitignore", "_dockerignore"]);
+
+    // 2. Copy specific template
+    copyDir(templateDir, target, ["_gitignore", "_dockerignore"]);
+
+    // 3. Dotfiles and Template Remapping
+    const remapping = {
+        "_gitignore": ".gitignore",
+        "_dockerignore": ".dockerignore",
+        "_titan.json": "titan.json",
+        ".env": ".env"
+    };
+    for (const [srcName, destName] of Object.entries(remapping)) {
+        const src = path.join(target, srcName);
+        const dest = path.join(target, destName);
+        if (fs.existsSync(src)) {
+            fs.renameSync(src, dest);
+        }
+    }
+
+    // Replace {{name}} in package.json and titan.json
+    const filesToSub = ['package.json', 'titan.json', 'README.md', 'index.js', 'app/app.js', 'app/app.ts'];
+    for (const f of filesToSub) {
+        const p = path.join(target, f);
+        if (fs.existsSync(p)) {
+            let content = fs.readFileSync(p, 'utf8');
+            content = content.replace(/{{name}}/g, projName);
+            // Also replace native_name (underscore version)
+            content = content.replace(/{{native_name}}/g, projName.replace(/-/g, '_'));
+            fs.writeFileSync(p, content);
+        }
+    }
+
+    console.log(chalk.gray(`  Installing dependencies...`));
+
+    await new Promise((resolve, reject) => {
+        const npm = spawn('npm', ['install'], {
+            cwd: target,
+            stdio: 'inherit',
+            shell: true
+        });
+        npm.on('error', reject);
+        npm.on('close', resolve);
+    });
+
+    console.log(chalk.green(`\n✔ Project '${projName}' created successfully!\n`));
+    console.log(chalk.yellow(`  cd ${projName}`));
+    console.log(chalk.yellow(`  npm run dev\n`));
+}

package/packages/cli/src/commands/migrate.js

@@ -0,0 +1,106 @@
+import fs from 'fs';
+import path from 'path';
+
+export async function migrateCommand() {
+    const root = process.cwd();
+    console.log(`\n🔍 Checking project for legacy Titan architecture...`);
+
+    const serverDir = path.join(root, 'server');
+    const titanDir = path.join(root, 'titan');
+    const pkgPath = path.join(root, 'package.json');
+
+    if (!fs.existsSync(serverDir) && !fs.existsSync(titanDir)) {
+        console.log(`✅ This project is already using the modern Titan runtime architecture.`);
+        return;
+    }
+
+    console.log(`\n⚠️ Legacy server architecture detected. Migrating to runtime-first model...`);
+
+    // 1. Delete server/
+    if (fs.existsSync(serverDir)) {
+        console.log(`   Deleting legacy server/ folder...`);
+        fs.rmSync(serverDir, { recursive: true, force: true });
+    }
+
+    // 2. Delete titan/ folder
+    if (fs.existsSync(titanDir)) {
+        console.log(`   Deleting legacy titan/ runtime folder...`);
+        fs.rmSync(titanDir, { recursive: true, force: true });
+    }
+
+    // 3. Update package.json
+    if (fs.existsSync(pkgPath)) {
+        console.log(`   Updating package.json...`);
+        try {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+            let modified = false;
+
+            // Update scripts
+            if (pkg.scripts) {
+                if (pkg.scripts.build && pkg.scripts.build.includes('cd server')) {
+                    pkg.scripts.build = "titan build";
+                    modified = true;
+                }
+                if (pkg.scripts.start && pkg.scripts.start.includes('cd server')) {
+                    pkg.scripts.start = "titan start";
+                    modified = true;
+                }
+                if (pkg.scripts.dev && pkg.scripts.dev.includes('titan/dev.js')) {
+                    pkg.scripts.dev = "titan dev";
+                    modified = true;
+                }
+            }
+
+            // Add dependencies
+            pkg.dependencies = pkg.dependencies || {};
+            if (!pkg.dependencies['@titan/native']) {
+                pkg.dependencies['@titan/native'] = "latest";
+                modified = true;
+            }
+            if (!pkg.dependencies['@titan/route']) {
+                pkg.dependencies['@titan/route'] = "latest";
+                modified = true;
+            }
+
+            if (modified) {
+                fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2));
+            }
+        } catch (e) {
+            console.log(`   ⚠️ Failed to update package.json automatically. Please do it manually.`);
+        }
+    }
+
+    // 4. Synchronize Dockerfile and other common files
+    try {
+        const commonDir = path.resolve(__dirname, '..', '..', '..', '..', 'templates', 'common');
+        if (fs.existsSync(commonDir)) {
+            const filesToSync = [
+                ['Dockerfile', 'Dockerfile'],
+                ['_dockerignore', '.dockerignore'],
+                ['_gitignore', '.gitignore'],
+                ['app/t.native.d.ts', 'app/t.native.d.ts'],
+                ['app/t.native.js', 'app/t.native.js']
+            ];
+
+            for (const [srcRel, destRel] of filesToSync) {
+                const src = path.join(commonDir, srcRel);
+                const dest = path.join(root, destRel);
+                if (fs.existsSync(src)) {
+                    // Create parent dir if needed
+                    const parent = path.dirname(dest);
+                    if (!fs.existsSync(parent)) {
+                        fs.mkdirSync(parent, { recursive: true });
+                    }
+                    fs.copyFileSync(src, dest);
+                }
+            }
+            console.log(`   Synchronized Dockerfiles and native definitions.`);
+        }
+    } catch (e) {
+        console.log(`   ⚠️ Failed to synchronize common template files.`);
+    }
+
+    console.log(`\n🎉 Migration complete!`);
+    console.log(`   Please run 'npm install' to fetch the new dependencies.`);
+    console.log(`   Then run 'titan dev' to start your application.\n`);
+}

package/packages/cli/src/commands/start.js

@@ -0,0 +1,5 @@
+import { startEngine } from "../engine.js";
+
+export function startCommand() {
+  startEngine(false);
+}

package/packages/cli/src/commands/update.js

@@ -0,0 +1,90 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import chalk from 'chalk';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export async function updateCommand() {
+    const root = process.cwd();
+    console.log(chalk.cyan(`\n→ Updating Titan project to latest...`));
+
+    const pkgPath = path.join(root, 'package.json');
+    if (!fs.existsSync(pkgPath)) {
+        console.log(chalk.red(`✖ No package.json found. Are you in a project root ? `));
+        return;
+    }
+
+    // 1. Update package.json versions
+    try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+        let modified = false;
+
+        const titanDeps = [
+            'titanpl',
+            'titanpl-sdk',
+            '@titanpl/cli',
+            '@titanpl/route',
+            '@titanpl/native',
+            '@titanpl/packet',
+            '@titanpl/core',
+            '@titanpl/node'
+        ];
+
+        if (pkg.dependencies) {
+            for (const dep of titanDeps) {
+                if (pkg.dependencies[dep]) {
+                    pkg.dependencies[dep] = "latest";
+                    modified = true;
+                }
+            }
+        }
+
+        if (pkg.devDependencies) {
+            for (const dep of titanDeps) {
+                if (pkg.devDependencies[dep]) {
+                    pkg.devDependencies[dep] = "latest";
+                    modified = true;
+                }
+            }
+        }
+
+        if (modified) {
+            fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+            console.log(chalk.green(`  ✔ Updated Titan dependencies in package.json`));
+        }
+    } catch (e) {
+        console.log(chalk.yellow(`  ⚠️ Failed to update package.json: ${e.message}`));
+    }
+
+    // 2. Refresh Dockerfile and dotfiles from templates
+    const commonDir = path.resolve(__dirname, '..', '..', '..', '..', 'templates', 'common');
+    if (fs.existsSync(commonDir)) {
+        const filesToSync = [
+            ['Dockerfile', 'Dockerfile'],
+            ['_dockerignore', '.dockerignore'],
+            ['_gitignore', '.gitignore'],
+        ];
+
+        for (const [srcName, destName] of filesToSync) {
+            const src = path.join(commonDir, srcName);
+            const dest = path.join(root, destName);
+            if (fs.existsSync(src)) {
+                fs.copyFileSync(src, dest);
+                console.log(chalk.green(`  ✔ Synchronized ${destName}`));
+            }
+        }
+
+        // Also update app/t.native.d.ts if it exists
+        const nativeTypesSrc = path.join(commonDir, 'app', 't.native.d.ts');
+        const nativeTypesDest = path.join(root, 'app', 't.native.d.ts');
+        if (fs.existsSync(nativeTypesSrc) && fs.existsSync(path.join(root, 'app'))) {
+            fs.copyFileSync(nativeTypesSrc, nativeTypesDest);
+            console.log(chalk.green(`  ✔ Updated app/t.native.d.ts`));
+        }
+    }
+
+    console.log(chalk.green(`\n✔ Update complete!\n`));
+    console.log(chalk.yellow(`  Please run 'npm install' to apply changes.\n`));
+}

package/packages/cli/src/engine.js

@@ -0,0 +1,143 @@
+import os from 'os';
+import path from 'path';
+import fs from 'fs';
+import { createRequire } from 'module';
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const require = createRequire(import.meta.url);
+
+export function getEngineBinaryPath() {
+  const platform = os.platform(); // 'win32', 'linux', 'darwin'
+  const arch = os.arch();         // 'x64', 'arm64'
+  const pkgName = `@titanpl/engine-${platform}-${arch}`;
+  const binName = platform === 'win32' ? 'titan-server.exe' : 'titan-server';
+
+  // 1. Robust Binary Discovery (Monorepo, Local, or Global)
+  const searchPaths = [
+    __dirname,
+    process.cwd(),
+    path.join(process.cwd(), '..'),
+    path.join(process.cwd(), '..', '..')
+  ];
+
+  for (let startPath of searchPaths) {
+    let current = startPath;
+    for (let i = 0; i < 8; i++) {
+      const potential = path.join(current, 'engine', 'target', 'release', binName);
+      if (fs.existsSync(potential)) return potential;
+
+      const parent = path.dirname(current);
+      if (parent === current) break;
+      current = parent;
+    }
+  }
+
+  // 2. Resolve installed optional dependency
+  try {
+    // We use a try/catch specifically for the resolve to provide a better diagnostic
+    let pkgPath;
+    try {
+      pkgPath = require.resolve(`${pkgName}/package.json`);
+    } catch (e) {
+      // Fallback: check if the binary exists in a standard location even if require.resolve fails
+      const fallbackBin = path.join(process.cwd(), 'node_modules', pkgName, 'bin', binName);
+      if (fs.existsSync(fallbackBin)) return fallbackBin;
+      throw e;
+    }
+    const pkgDir = path.dirname(pkgPath);
+    const binaryPath = path.join(pkgDir, 'bin', binName);
+
+    if (fs.existsSync(binaryPath)) {
+      return binaryPath;
+    }
+    throw new Error(`Corrupted installation: Binary missing at ${binaryPath}.`);
+  } catch (err) {
+    console.error(`\n[TITAN FATAL] Unsupported platform: ${platform} (${arch})`);
+    console.error(`Or the optional dependency '${pkgName}' failed to install.`);
+    console.error(`Error: ${err.message}\n`);
+    process.exit(1);
+  }
+}
+
+export function startEngine(watchMode = false) {
+  const distPath = path.resolve(process.cwd(), 'dist');
+
+  if (!fs.existsSync(distPath)) {
+    console.error("❌ 'dist/' directory not found. Please run 'titan build' first.");
+    process.exit(1);
+  }
+
+  const binaryPath = getEngineBinaryPath();
+
+  // Arguments passed to Rust backend
+  const args = ['run', distPath];
+  if (watchMode) args.push('--watch');
+
+  console.log(`🚀 Starting Titan Engine...`);
+
+  const engineProcess = spawn(binaryPath, args, {
+    stdio: ['inherit', 'pipe', 'pipe'],
+    env: {
+      ...process.env,
+      TITAN_ENV: watchMode ? 'development' : 'production',
+      Titan_Dev: watchMode ? '1' : '0'
+    }
+  });
+
+  let stderrBuffer = "";
+
+  engineProcess.stdout.pipe(process.stdout);
+  engineProcess.stderr.on('data', (data) => {
+    const chunk = data.toString();
+    stderrBuffer += chunk;
+    process.stderr.write(data);
+  });
+
+  engineProcess.on('close', (code) => {
+    if (code !== 0 && code !== null) {
+      // Check for port binding errors
+      const isPortError = stderrBuffer.includes("Address already in use") ||
+        stderrBuffer.includes("address in use") ||
+        stderrBuffer.includes("os error 10048") || // Windows
+        stderrBuffer.includes("EADDRINUSE") ||
+        stderrBuffer.includes("AddrInUse");
+
+      if (isPortError) {
+        // Try to read intended port
+        let port = 5100;
+        try {
+          const routesPath = path.join(process.cwd(), "dist", "routes.json");
+          if (fs.existsSync(routesPath)) {
+            const routesConfig = JSON.parse(fs.readFileSync(routesPath, "utf8"));
+            if (routesConfig && routesConfig.__config && routesConfig.__config.port) {
+              port = routesConfig.__config.port;
+            }
+          }
+        } catch (e) { }
+
+        const cyan = (t) => `\x1b[36m${t}\x1b[0m`;
+        const yellow = (t) => `\x1b[33m${t}\x1b[0m`;
+        const red = (t) => `\x1b[31m${t}\x1b[0m`;
+
+        console.log("");
+        console.log(red("⏣  Your application cannot enter this orbit"));
+        console.log(red(`↳  Another application is already bound to port ${port}.`));
+        console.log("");
+
+        console.log(yellow("Recommended Actions:"));
+        console.log(yellow("  1.") + " Release the occupied orbit (stop the other service).");
+        console.log(yellow("  2.") + " Assign your application to a new orbit in " + cyan("app/app.js"));
+        console.log(yellow("     Example: ") + cyan(`t.start(${port + 1}, "Titan Running!")`));
+        console.log("");
+      } else {
+        console.error(`\n❌ [Titan Engine died with exit code ${code}]`);
+      }
+    }
+  });
+
+  return engineProcess;
+}

package/packages/engine-darwin-arm64/README.md

@@ -0,0 +1,13 @@
+# @titanpl/engine-darwin-arm64
+
+The macOS ARM64 pre-compiled native engine binary for Titan Planet.
+
+## What it works (What it does)
+This package is the compiled core Rust + Axum server embedded with the Boa JavaScript runtime. It is specifically built for Apple Silicon (ARM64) macOS devices.
+
+## How it works
+This package is listed as an "optional dependency" in `@titanpl/cli`. During package installation, your package manager identifies the OS and automatically downloads this binary if it matches `darwin` + `arm64`. You do not need to install it directly. 
+
+When you run `titan start`, the CLI locates this binary and executes it as your web server.
+
+**Important Note:** Currently, Titan Planet and its entire package ecosystem are only for Windows. The Linux and macOS versions are in development (dev only) for the new architecture and will be launched later.

package/packages/engine-darwin-arm64/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "@titanpl/engine-darwin-arm64",
+  "version": "26.17.2",
+  "os": [
+    "darwin"
+  ],
+  "cpu": [
+    "arm64"
+  ]
+}

package/packages/engine-linux-x64/README.md

@@ -0,0 +1,11 @@
+# @titanpl/engine-linux-x64
+
+The Linux x64 pre-compiled native engine binary for Titan Planet.
+
+## What it works (What it does)
+This package holds the core Rust + Axum high-performance web server tightly coupled with the Boa JavaScript execution runtime. It is built natively for Linux x64 environments, requiring no Node.js execution layer.
+
+## How it works
+You don't need to manually interact with this module. It acts as an optional dependency resolved by `#titanpl/cli`. If you run TitanPlanet on a Linux x64 machine, npm/yarn automatically downloads this native binary to run your application.
+
+**Important Note:** Currently, Titan Planet and its entire package ecosystem are only for Windows. The Linux version is in development (dev only) for the new architecture and will be launched later.

package/packages/engine-linux-x64/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "@titanpl/engine-linux-x64",
+  "version": "26.17.2",
+  "os": [
+    "linux"
+  ],
+  "cpu": [
+    "x64"
+  ]
+}

package/packages/engine-win32-x64/README.md

@@ -0,0 +1,11 @@
+# @titanpl/engine-win32-x64
+
+The Windows x64 pre-compiled native engine binary for Titan Planet.
+
+## What it works (What it does)
+This module provides the highly concurrent Rust-based server binary (`titan.exe`) powered by Axum and Boa. It removes the necessity of a Node.js event loop by only executing static routes in Rust and specific dynamic logic in embedded JavaScript.
+
+## How it works
+Like the other engine packages, this works entirely behind the scenes. When `@titanpl/cli` is installed on a Windows instance, it fetches this `.exe` runtime. The CLI then maps your built assets and JS routes into the binary for deployment.
+
+**Important Note:** Currently, Titan Planet and its entire package ecosystem are only for Windows. The Linux version is in development (dev only) for the new architecture and will be launched later.

package/packages/engine-win32-x64/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "@titanpl/engine-win32-x64",
+  "version": "26.17.2",
+  "os": [
+    "win32"
+  ],
+  "cpu": [
+    "x64"
+  ]
+}

package/packages/native/README.md

@@ -0,0 +1,11 @@
+# @titanpl/native
+
+The native utility extension module for Titan Planet.
+
+## What it works (What it does)
+It acts as the low-level communication bridge offering type definitions and utility wrappers out-of-the-box. Rather than being dependent on heavy JavaScript libraries, this package bridges Node-style features gracefully to the Titan runtime environment. 
+
+## How it works
+You can import tools and primitives from this package into your server-side actions alongside `@titanpl/core` when you want direct low-level interaction or need access to platform operations that interact directly with the C/Rust engine.
+
+**Important Note:** Currently, Titan Planet and its entire package ecosystem are only for Windows. The Linux version is in development (dev only) for the new architecture and will be launched later.