Languages & Runtimes

Run Node.js, Python, Java, Go, PHP and other languages on Falix application servers.

Node.js on Falix

Everything the Node.js application decides for you — the index.js entry file, automatic npm install, SERVER_PORT — and how to work with it instead of against it.

BeginnerTemplate

Python on Falix

How the Python application runs your code — the app.py entry file, automatic requirements.txt installs, SERVER_PORT for web apps — and the few rules that make any Python tutorial work here.

BeginnerTemplate

Bun is a fast JavaScript runtime that executes TypeScript with no build step — the easy path for TS on Falix. Here's how the Bun application runs your code, from the entry file to SERVER_PORT.

BeginnerTemplate

The Java application runs one runnable jar. Build a fat jar locally (or with a Git post-deploy step), upload it, and start — here's how to package it so it runs the first time.

Falix has three PHP applications — CLI, Composer, and Web Server. Here's what each one runs, when to pick it, and how to get dependencies and a website working.

IntermediateTemplate

The Go application runs a prebuilt binary named app — nothing compiles on start. Build it locally or with a Git post-deploy step, and read SERVER_PORT to serve web traffic.

The Rust application compiles your project with cargo on every start — slow the first time, fast after that. Here's how the build cache works, a std-only web server, and how to add crates.

C#, Deno, Dart, Elixir, and Lua on Falix

Beyond the headline languages, Falix runs five more application types. Here's the entry point, dependency story, and one gotcha for each — enough to get running without surprises.

ESM vs CommonJS on Falix

Two module systems, one Node runner. What "type":"module" actually flips, which errors still bite on Falix's Node, and the exact fix for each — verified in the real container.

Finding Node.js memory leaks

Read process.memoryUsage(), recognise the handful of patterns that leak memory in bots and web apps, and find the culprit before an out-of-memory kill finds it for you.

Async patterns for bots and web apps

Promises, async/await, and the one mistake that silently crashes your whole app. The async patterns that fit Discord bots and web servers on Falix, with the traps called out.

Pinning Python requirements

== vs >= vs ~= in requirements.txt, what each one resolves to, and why the Python app's install-on-every-start makes pinning matter more here than on your laptop.

Poetry and uv on Falix

Poetry and uv manage dependencies through pyproject.toml and a lockfile — but the Python app only auto-installs requirements.txt on start. Here's what that means and the two paths that actually work.

asyncio for bots and scrapers

Python's async model in plain terms — how discord.py and async scrapers do many things at once on one thread, and the one blocking call that freezes all of it.

TypeScript projects on Falix

The compile-on-install pattern that runs any TypeScript project on the Node.js app — web servers, APIs, workers, not just bots — plus the honest limits: path aliases and watch mode.

Bun deep dive: config, tests, workspaces

Beyond the basics — bunfig.toml settings, Bun's built-in test runner, and how monorepo workspaces behave on Falix, with the one-entry-per-server reality called out.

Java build tools: Gradle vs Maven

The Java app runs one fat jar — your build tool makes it. How to choose between Maven and Gradle, with a minimal, complete fat-jar config for each that produces a ready-to-run app.jar.

JDA, Javacord, and Discord4J compared

Java has three real Discord libraries, not one. Here's how JDA, Javacord, and Discord4J differ in style and community — and why all three run on Falix the exact same way.

Go modules in depth

What go.mod and go.sum actually mean, how to upgrade dependencies safely, when to vendor — and how the Packages page fits a runtime that compiles ahead of time.

Async Rust with Tokio on Falix

How async/await and the Tokio runtime shape a Rust service — with a verified minimal echo server that reads SERVER_PORT — plus the honest truth about compile time on this runtime.

Long-running PHP workers

PHP isn't only for websites — a while-loop worker runs fine on the PHP CLI application. Here's a verified worker with graceful shutdown, and exactly how restart, stop, and crash behave on Falix.

The Lua application runs Luvit — Lua on libuv, the event loop behind Node. Here's how its async model, timers, and HTTP server work, a server that binds SERVER_PORT, and an honest look at the ecosystem.

OTP basics — GenServer and supervisors

Elixir's real superpower is OTP: processes, GenServers that hold state, and supervisors that restart what crashes. Here's the mental model for always-up apps, and the Mix project Falix needs to run one.

.NET console apps and background services

The C# application compiles and runs your project with dotnet run on every start. Here's how the Project location and project file variables work, and the BackgroundService pattern for a worker that stays up.

Deno on Falix in depth

How Deno's imports and deno.json work, why npm: and jsr: specifiers mean no install step — and the honest, verified truth about Deno's permission model and what it costs on a free plan.

Which language should I use?

An honest chooser across every runtime Falix offers — by what you're building, what you already know, and how each one actually runs here. No favourites, just trade-offs and a link to the right guide.