Supported stacks

Tenbi's runner installs a project's toolchain on demand at workspace prep, then runs the AI phases against it. A repo whose stack the runner can't execute is stopped before any AI spend (see Stack unsupported). This page lists what's executable today.

Matrix

Stack	Status	How the version is chosen
JavaScript / TypeScript (npm/Node)	Supported	engines.node, else .nvmrc, else latest LTS. Window Node 12–26.
Python	Beta	.python-version pin honored; else requires-python (treated as a floor → newest supported version); else latest stable. Window 3.9–3.14.
Go	Beta	go.mod toolchain directive honored as a pin; else the go directive (a minimum → newest supported version); else latest stable. Window 1.21–1.26.
.NET	Beta	global.json SDK version honored as a pin (rollForward respected); else newest supported SDK (a newer SDK builds all supported TargetFrameworks). SDK window 8–10.
Ruby	Beta	.ruby-version pin honored; else the Gemfile ruby directive (exact = pin, constraints → newest supported version); else latest stable. Window 3.2–3.4.
Rust	Beta	rust-toolchain(.toml) honored as a pin (stable channel = latest); else Cargo.toml rust-version (a minimum → newest supported version); else latest stable. Window 1.85–1.97.
Java	Beta	.java-version / .sdkmanrc / Gradle toolchain declaration honored as a pin; else pom/Gradle bytecode targets (a minimum → newest supported JDK); else JDK 25. Window JDK 11–25 (Temurin).
PHP	Roadmap	— (fails preflight)

Polyglot workspaces work: a repo needing Node, Python, Go, .NET, Ruby, Rust and Java in any combination resolves all of them.

Python (Beta)

Python is available to try. Details worth knowing:

• Version selection. A .python-version file is a real pin — Tenbi runs that minor. A requires-python in pyproject.toml is read as a compatibility floor, not a preference: Tenbi picks the newest supported version that satisfies it (so >=3.9 runs on 3.14, not 3.9). A Python repo that declares neither runs on the latest stable version. The supported window is 3.9–3.14.
• Isolated environment. Tenbi sets up a workspace virtual environment before the run, so pip install … and tools like pytest just work — no manual venv step, and the command lands on PATH.
• Package managers. pip (bundled) and uv are available.
• Poetry and PDM aren't supported yet. A repo with a poetry.lock or pdm.lock stops early with a clear message rather than half-running — those tools manage their own environments. Remove the lock file to use the standard pip path, or wait for support.
• Beta caveat. The supported version range and tooling may expand. Nothing here changes how existing JavaScript/TypeScript projects run.

Go (Beta)

Go is available to try. Details worth knowing:

• Version selection. A toolchain go1.X.Y directive in go.mod is a real pin — Tenbi runs that minor. The go 1.X directive is what Go itself says it is: a minimum — Tenbi picks the newest supported toolchain that satisfies it (so go 1.22 runs on 1.26, exactly as the go command would). A go.mod with neither runs the latest stable. The supported window is 1.21–1.26; a pin below the floor or a go directive above the ceiling stops early with a clear message rather than running the wrong toolchain.
• Pinned means pinned. Tenbi sets GOTOOLCHAIN=local, so the go command never downloads a different toolchain behind your back — the resolved version is the one that runs.
• Modules and vendoring. Standard go.mod/go.sum module resolution; a committed vendor/ directory is used automatically. No extra setup.
• Beta caveat. The supported window and tooling may expand. Nothing here changes how existing JavaScript/TypeScript or Python projects run.

.NET (Beta)

.NET is available to try. Details worth knowing:

• Version selection. A global.json sdk.version is honored as a pin at SDK-major granularity (rollForward policies that stay within a major behave as written; latestMajor is treated as a minimum and resolves up). Without global.json, Tenbi runs the newest supported SDK — a newer SDK builds every supported TargetFramework, so nothing is lost. The supported SDK window is 8–10.
• TargetFrameworks are checked up front. A project targeting a newer .NET than the supported ceiling stops early with a clear message. Windows-only targets (.NET Framework monikers like net48, or -windows suffixed TFMs) also stop early — Tenbi's runners are Linux, so this is a platform limit rather than a roadmap item.
• NuGet restores per-run against nuget.org; private feeds aren't supported yet. dotnet test drives the test phases as usual.
• Not yet supported: dotnet workload-based projects (MAUI, WASM) — these fail during the run rather than up front; treat that as a Beta rough edge.
• Beta caveat. The supported window and tooling may expand. Nothing here changes how existing JS/TS, Python or Go projects run.

Ruby (Beta)

Ruby is available to try — including Rails. Details worth knowing:

• Version selection. A .ruby-version file is a real pin and governs. The Gemfile's ruby directive is honored too: an exact version is a pin; constraint forms (">= 3.2", "~> 3.3", ranges) resolve to the newest supported version satisfying them. Neither declared → latest stable. The supported window is 3.2–3.4 (MRI only — JRuby/TruffleRuby aren't supported).
• Gems and native extensions. Bundler is included, and the runner carries a build toolchain, so gems with C extensions — including the default Rails set (bootsnap and friends) and pg — install normally. Gems live in a per-run workspace directory; nothing touches your repo.
• Rails. Rails apps work end-to-end: SQLite (the Rails 8 default) and Postgres are covered; importmap/propshaft apps need no Node and jsbundling apps use the runner's Node. Two honest gaps: system/browser tests are out of scope (no browser in runners — unit, model and request specs run fine), and MySQL-backed apps aren't supported yet.
• Beta caveat. The supported window and tooling may expand. Nothing here changes how existing JS/TS, Python, Go or .NET projects run.

Rust (Beta)

Rust is available to try. Details worth knowing:

• Version selection. A rust-toolchain.toml (or legacy rust-toolchain) file naming a version is a real pin and governs; channel = "stable" means latest supported. Otherwise Cargo.toml's rust-version (the MSRV) is treated as a minimum → the newest supported version. Neither declared → latest stable. The supported window is 1.85–1.97.
• Stable only. Repos pinning a nightly or beta channel fail up front — moving channels can't be reproduced run-to-run. Pin a stable version instead.
• Cargo and crates. cargo build / cargo test / clippy / rustfmt all work; the runner carries a C toolchain, so -sys crates that compile native code link normally. The crate cache lives in a per-run workspace directory; nothing touches your repo.
• Build time. A first build compiles the full dependency tree — large dependency graphs can take minutes, which counts toward the run's phase time. Typical crates are fine; very heavy workspaces may run long.
• Beta caveat. The supported window and tooling may expand. Nothing here changes how existing JS/TS, Python, Go, .NET or Ruby projects run.

Java (Beta)

Java is available to try — Maven and Gradle both. Details worth knowing:

• Version selection. A .java-version or .sdkmanrc file — or a Gradle toolchain declaration (JavaLanguageVersion.of(N) / jvmToolchain(N)) — is a pin and governs. Bytecode targets (maven.compiler.release/source/ target, Spring's java.version, Gradle sourceCompatibility) are minimums: a newer JDK builds them via --release. Nothing declared → JDK 25. The supported window is JDK 11–25 (Temurin builds); one JDK per run — a workspace declaring several Gradle toolchains gets the newest.
• Build tools. Wrappers are preferred: ./gradlew and ./mvnw run with the exact build-tool version your repo pins. Repos without a wrapper get Maven 3.9 or Gradle 9 provided. Dependency caches (~/.m2-equivalent, Gradle distributions) live in per-run workspace directories; first builds download dependencies fresh, which counts toward phase time — Spring Boot-sized projects take a few minutes on the first build.
• Kotlin. Kotlin-on-Gradle projects generally work (the compiler arrives as a Gradle plugin), but Kotlin isn't separately validated yet. Scala/sbt isn't supported.
• Android is out of scope — runners carry no Android SDK, and Android projects fail up front with a named reason. This is a platform limit, not a roadmap item.
• Beta caveat. The supported window and tooling may expand. Nothing here changes how existing stacks run.