[Feat] Add Go, Rust and Python application runtimes

app/Providers/ComponentServiceProvider.php

@@ -9,10 +9,13 @@
 use App\Plugins\RegisterRuntimePreset;
 use App\RuntimePresets\Bun;
 use App\RuntimePresets\Custom;
+use App\RuntimePresets\Go;
 use App\RuntimePresets\Laravel;
 use App\RuntimePresets\NodeJS;
 use App\RuntimePresets\PHP;
 use App\RuntimePresets\Pnpm;
+use App\RuntimePresets\Python;
+use App\RuntimePresets\Rust;
 use App\RuntimePresets\StaticSite;
 use App\RuntimePresets\Yarn;
 use Illuminate\Support\ServiceProvider;
@@ -23,7 +26,7 @@ public function register(): void {}
 
     public function boot(): void
     {
-        foreach ([PHP::class, NodeJS::class, Bun::class, Pnpm::class, Yarn::class, StaticSite::class, Custom::class, Laravel::class] as $preset) {
+        foreach ([PHP::class, NodeJS::class, Bun::class, Pnpm::class, Yarn::class, StaticSite::class, Custom::class, Go::class, Rust::class, Python::class, Laravel::class] as $preset) {
             RegisterRuntimePreset::make($preset::id())
                 ->handler($preset)
                 ->register();

app/Providers/ToolingServiceProvider.php

@@ -5,9 +5,11 @@
 use App\Tooling\BunTooling;
 use App\Tooling\ComposerTooling;
 use App\Tooling\DotnetTooling;
+use App\Tooling\GoTooling;
 use App\Tooling\NodeTooling;
 use App\Tooling\PnpmTooling;
 use App\Tooling\PythonTooling;
+use App\Tooling\RustTooling;
 use App\Tooling\YarnTooling;
 use Illuminate\Support\ServiceProvider;
 
@@ -22,6 +24,8 @@ public function register(): void
                 PnpmTooling::class,
                 YarnTooling::class,
                 PythonTooling::class,
+                GoTooling::class,
+                RustTooling::class,
                 DotnetTooling::class,
                 ComposerTooling::class,
             ],

app/RuntimePresets/AbstractRuntimePreset.php

@@ -190,7 +190,7 @@ public function detect(RepositoryFiles $files): ?array
     }
 
     /**
-     * Versions satisfying a Composer or npm style constraint, newest first. An empty, unparsable or
+     * Versions satisfying a Composer, npm or Python style constraint, newest first. An empty, unparsable or
      * unsatisfiable constraint returns every version, so detection never removes the user's choices.
      *
      * @return list<string>
@@ -236,7 +236,7 @@ private function withinCaret(array $version, array $target): bool
     private function satisfies(string $version, string $constraint): bool
     {
         foreach (preg_split('/[\s,]+/', $constraint, flags: PREG_SPLIT_NO_EMPTY) ?: [] as $part) {
-            if (! preg_match('/\A(\^|~|>=|<=|>|<|=)?v?(\d+(?:\.\d+)*)/', $part, $match)) {
+            if (! preg_match('/\A(\^|~=|~|>=|<=|!=|==|>|<|=)?v?(\d+(?:\.\d+)*)(?:\.[x*])*(?:[-+@][0-9a-z.+@-]+|[._]?(?:a|b|rc|post|dev)\d+)?\z/i', $part, $match)) {
                 return false;
             }
             $precision = min(substr_count($version, '.'), substr_count($match[2], '.')) + 1;
@@ -245,7 +245,8 @@ private function satisfies(string $version, string $constraint): bool
             $sameMajor = (int) $version === (int) $match[2];
             $satisfied = match ($match[1]) {
                 '^' => $sameMajor && version_compare($current, $target, '>=') && $this->withinCaret(explode('.', $version), explode('.', $match[2])),
-                '~' => substr_count($match[2], '.') >= 2 ? version_compare($current, $target, '==') : $sameMajor && version_compare($current, $target, '>='),
+                '~', '~=' => substr_count($match[2], '.') >= 2 ? version_compare($current, $target, '==') : $sameMajor && version_compare($current, $target, '>='),
+                '!=' => substr_count($match[2], '.') > substr_count($version, '.') || version_compare($current, $target, '!='),
                 '>=', '<=', '>', '<' => version_compare($current, $target, $match[1]),
                 default => version_compare($current, $target, '=='),
             };

app/RuntimePresets/Go.php

@@ -0,0 +1,53 @@
+<?php
+
+namespace App\RuntimePresets;
+
+use App\Enums\WebMode;
+use App\Support\RepositoryFiles;
+use App\Tooling\GoTooling;
+
+class Go extends AbstractRuntimePreset
+{
+    public static function id(): string
+    {
+        return 'go';
+    }
+
+    public static function label(): string
+    {
+        return 'Go';
+    }
+
+    public function versions(): array
+    {
+        return GoTooling::supportedVersions();
+    }
+
+    public function tooling(): ?string
+    {
+        return GoTooling::id();
+    }
+
+    public function webMode(): WebMode
+    {
+        return WebMode::PROXY;
+    }
+
+    public function startCommand(): ?string
+    {
+        return './app';
+    }
+
+    public function detect(RepositoryFiles $files): ?array
+    {
+        if (! $files->has('go.mod') || $files->has('composer.json')) {
+            return null;
+        }
+        $constraint = $files->get('.go-version');
+        if (! $constraint && preg_match('/^go\h+(\d+\.\d+(?:\.\d+)?)/m', $files->get('go.mod') ?? '', $match)) {
+            $constraint = '>='.$match[1];
+        }
+
+        return $this->compatibleVersions($constraint);
+    }
+}

app/RuntimePresets/Python.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace App\RuntimePresets;
+
+use App\Enums\WebMode;
+use App\Support\RepositoryFiles;
+use App\Tooling\PythonTooling;
+
+class Python extends AbstractRuntimePreset
+{
+    public static function id(): string
+    {
+        return 'python';
+    }
+
+    public static function label(): string
+    {
+        return 'Python';
+    }
+
+    public function versions(): array
+    {
+        return PythonTooling::supportedVersions();
+    }
+
+    public function tooling(): ?string
+    {
+        return PythonTooling::id();
+    }
+
+    public function webMode(): WebMode
+    {
+        return WebMode::PROXY;
+    }
+
+    public function startCommand(): ?string
+    {
+        return '.venv/bin/python main.py';
+    }
+
+    public function detect(RepositoryFiles $files): ?array
+    {
+        if ((! $files->has('requirements.txt') && ! $files->has('pyproject.toml') && ! $files->has('setup.py')) || $files->has('composer.json')) {
+            return null;
+        }
+
+        return $this->compatibleVersions($files->get('.python-version') ?? $files->tomlString('pyproject.toml', 'project', 'requires-python'));
+    }
+}

app/RuntimePresets/Rust.php

@@ -0,0 +1,52 @@
+<?php
+
+namespace App\RuntimePresets;
+
+use App\Enums\WebMode;
+use App\Support\RepositoryFiles;
+use App\Tooling\RustTooling;
+
+class Rust extends AbstractRuntimePreset
+{
+    public static function id(): string
+    {
+        return 'rust';
+    }
+
+    public static function label(): string
+    {
+        return 'Rust';
+    }
+
+    public function versions(): array
+    {
+        return RustTooling::supportedVersions();
+    }
+
+    public function tooling(): ?string
+    {
+        return RustTooling::id();
+    }
+
+    public function webMode(): WebMode
+    {
+        return WebMode::PROXY;
+    }
+
+    public function startCommand(): ?string
+    {
+        return './target/release/app';
+    }
+
+    public function detect(RepositoryFiles $files): ?array
+    {
+        if (! $files->has('Cargo.toml') || $files->has('composer.json')) {
+            return null;
+        }
+
+        $file = $files->has('rust-toolchain') ? 'rust-toolchain' : 'rust-toolchain.toml';
+        $constraint = $files->tomlString($file, 'toolchain', 'channel') ?? ($file === 'rust-toolchain' ? $files->get($file) : null);
+
+        return $this->compatibleVersions($constraint);
+    }
+}

app/Support/RepositoryFiles.php

@@ -34,6 +34,28 @@ public function get(string $path): ?string
         return $this->contents[$path];
     }
 
+    /**
+     * Reads single-line quoted hints from a TOML table, ignoring multiline string bodies.
+     */
+    public function tomlString(string $path, string $table, string $key): ?string
+    {
+        $contents = preg_replace(
+            <<<'REGEX'
+            /"""(?:\\.|(?!""").)*"""|'''.*?'''|(?:"(?:\\.|[^"\\\r\n])*"|'[^'\r\n]*'|#[^\r\n]*)(*SKIP)(*F)/s
+            REGEX,
+            '',
+            $this->get($path) ?? '',
+        ) ?? '';
+        if (! preg_match('/^\h*\[\h*'.preg_quote($table, '/').'\h*\]\h*(?:#[^\r\n]*)?\r?$(.*?)(?=^\h*\[|\z)/ms', $contents, $section)) {
+            return null;
+        }
+        if (! preg_match('/^\h*'.preg_quote($key, '/').'\h*=\h*(["\'])([^"\'\r\n]*)\1\h*(?:#[^\r\n]*)?\r?$/m', $section[1], $value)) {
+            return null;
+        }
+
+        return $value[2];
+    }
+
     /**
      * @return array<string, mixed>
      */

app/Tooling/GoTooling.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Tooling;
+
+class GoTooling extends AbstractMiseTooling
+{
+    public static function id(): string
+    {
+        return 'go';
+    }
+
+    public static function label(): string
+    {
+        return 'Go';
+    }
+
+    public static function description(): string
+    {
+        return 'Go toolchain used to build Go applications during deployment.';
+    }
+
+    public static function supportedVersions(): array
+    {
+        return ['1.27', '1.26', '1.25'];
+    }
+
+    public static function commands(): array
+    {
+        return ['go', 'gofmt'];
+    }
+}

app/Tooling/RustTooling.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Tooling;
+
+class RustTooling extends AbstractMiseTooling
+{
+    public static function id(): string
+    {
+        return 'rust';
+    }
+
+    public static function label(): string
+    {
+        return 'Rust';
+    }
+
+    public static function description(): string
+    {
+        return 'Rust toolchain used to build Rust applications during deployment.';
+    }
+
+    public static function supportedVersions(): array
+    {
+        return ['1.99', '1.98', '1.97'];
+    }
+
+    public static function commands(): array
+    {
+        return ['cargo', 'rustc', 'rustup', 'rustfmt'];
+    }
+}

docs/4.x/applications/concepts.md

@@ -20,11 +20,20 @@ The deployment core is runtime-agnostic. Presets suggest editable scripts, comma
 | Laravel | FPM | Suggested build/release scripts, public directory and shared storage |
 | Node | Proxy | Per-component Node tooling and a managed application process |
 | Bun | Proxy | Per-component Bun tooling and a managed application process |
+| Go | Proxy | Per-component Go toolchain; builds `./app` from the root package |
+| Rust | Proxy | Per-component Rust toolchain; builds with Cargo in release mode |
+| Python | Proxy | Per-component Python tooling and a virtual environment in each release |
 | Static | Static | Files served directly by the webserver |
-| Custom | Proxy | Your commands, for example a Python or Go service |
+| Custom | Proxy | Your commands for a runtime not covered by a preset |
 
 **FPM** sends requests to a PHP-FPM pool. **Proxy** forwards to a process listening on the component's `PORT`. **Static** serves files only. Plugins can register additional presets and must choose a web mode explicitly. Custom does not install an arbitrary runtime for you: prepare its tools on the server or provide a plugin preset.
 
+Go is detected from `go.mod`, Rust from `Cargo.toml`, and Python from `requirements.txt`, `pyproject.toml` or `setup.py`. Version hints come from `.go-version` (or the minimum Go version in `go.mod`), the channel in `rust-toolchain` or `rust-toolchain.toml`, and `.python-version` (or `[project].requires-python` in `pyproject.toml` when the pin file is absent). Rust's legacy plain-text `rust-toolchain` format is also supported, and that filename takes precedence when both toolchain files exist. TOML hints are read from unescaped single-line quoted values; escaped or multiline hint values are not interpreted. Missing or unsupported hints leave all supported versions available. PHP/Composer repositories keep their existing detection priority, even when they include tooling for another language.
+
+Go, Rust and Python version choices select a minor release series, not an exact patch. Detection is a best-effort suggestion: a strict Python requirement such as `==3.12.4` is not guaranteed by selecting `3.12`, because Mise installs a patch release from that series. Projects requiring an exact toolchain need a prepared Custom runtime or a plugin preset rather than relying on automatic detection.
+
+These presets are framework-neutral starting points. Go builds the repository root with `go build -o app .`; change the package path for projects using a layout such as `./cmd/server`. Rust respects an existing `Cargo.lock`; change the suggested `./target/release/app` start command to your Cargo binary's name. Python creates `.venv` inside each release and installs `requirements.txt`, or installs the project with pip when using `pyproject.toml` or `setup.py`. Its default start command is `.venv/bin/python main.py`; replace it with your production WSGI/ASGI command when needed, and include its server package in your dependencies. Poetry/uv-only projects need an adapted build script. Do not share `.venv` between releases. All web processes must listen on `127.0.0.1` and the supplied `PORT`. Native dependencies may require additional system packages on the server.
+
 ## Getting started
 
 Click **New application**, pick a repository and a server, then click **Deploy**. Vito:

resources/deployment-scripts/presets/go/build.sh

@@ -0,0 +1,2 @@
+go mod download
+go build -o app .

resources/deployment-scripts/presets/python/build.sh

@@ -0,0 +1,6 @@
+python -m venv .venv
+if [ -f requirements.txt ]; then
+  .venv/bin/python -m pip install -r requirements.txt
+elif [ -f pyproject.toml ] || [ -f setup.py ]; then
+  .venv/bin/python -m pip install .
+fi

resources/deployment-scripts/presets/rust/build.sh

@@ -0,0 +1,5 @@
+if [ -f Cargo.lock ]; then
+  cargo build --release --locked
+else
+  cargo build --release
+fi