Flux 1.1.38, based on Godot Engine 4.7.2

From New game to an approved build, in one engine.

Templates to start from, 26 frameworks to build on, and a release check that plays the exact build that goes out.

See what it does How a studio gets Flux

The Flux editor, build 4.7.2-flux-1.1.20, in Flux's navy and cyan: a game made from the 3D template, its world scene in the 3D view and the Player selected in the Inspector.

Languages

Start in C#. Go all the way down to C.

GDScript, C#, C++ and C sit side by side in one game. This is how far down Flux goes.

C#C++Cvcpkg

var store = WPDSaveStore.New(1);
store.Saved += (slot, error) => GD.Print($"{slot} saved: {error}");
store.SaveSlotAsync("one",
    new Godot.Collections.Dictionary { { "score", 12 } });

WPDSaveStore.Loaded loaded = store.LoadSlot("one");
int score = loaded.Data["score"].AsInt32();

var audio = WPDAudio.From(GetNode("/root/Audio"));
audio.SetVolume("Music", 0.5);

C++

#include <godot_cpp/classes/node.hpp>

class Gameplay : public godot::Node {
	GDCLASS(Gameplay, godot::Node)

public:
	int answer() const;
	double get_speed() const;
	void set_speed(double p_speed);

protected:
	static void _bind_methods();

private:
	double speed = 1.0;
};

#include <flux_c_api.h>

typedef struct {
	GDExtensionObjectPtr owner;
	double speed;
} Gameplay;

static void answer(void *instance, const flux_c_value *args, flux_c_value *ret) {
	ret->i = 42;
}

static void initialize(void *userdata, GDExtensionInitializationLevel level) {
	if (level != GDEXTENSION_INITIALIZATION_SCENE) {
		return;
	}
	flux_c_register_class("Gameplay", "Node", sizeof(Gameplay), made, NULL);
	const flux_c_param returns_int = { NULL, GDEXTENSION_VARIANT_TYPE_INT, NULL };
	flux_c_register_method("Gameplay", "answer", answer, returns_int, 0, NULL);
}

vcpkg

[native]

presets={"debug": "Debug", "release": "Release"}
toolchain="msvc"
projects={"gameplay": "c_gdextension", "mathlib": "static"}
cxx_standard=23
c_standard=23
packages={"fmt": "10.2.1", "zlib": "", "curl[ssl]": ""}

Every Flux addon, in C#'s own types

Levels of detail

A town of 400 houses in under a fifth of the time.

Drop one LOD group over an object and Flux works out its distances from its size: a house swaps for a simple stand-in at about 100 m, and a crate drops out at about 80 m. Every switch is a clean cut that waits a few metres before it undoes, so nothing flickers on the line.

An illustration of the town Flux's tests draw. The numbers are the tests' own: 400 houses on an NVIDIA GeForce RTX 5070 Ti, each object a draw call.

Objects drawn: 6,0026,002 plain, 528 with LOD
Triangles: 1,505,6241,505,624 plain, 45,476 with LOD
CPU time of a frame: 4.4 ms4.4 ms plain, 0.8 ms with LOD

Large worlds

Only what's near is loaded

A world cut into cells loads the ones round the player on other threads, ahead of where they're heading, and frees the ones behind. Every cell further off draws a stand-in, so the horizon is never empty.

Measured144 cells flown over at 80 m/s, every cell near the camera in on every frame, the longest frame 8 ms on Forward+ with at most 61 cells in at once. Stand-ins reach 2 km.

Province maps

A strategy map from one picture

Paint every province a flat colour of its own and Flux reads the map from it. A map mode is only a table of colours, so switching it repaints every province at once. Rest the mouse on one to light it.

MeasuredA 4096x2048 map of 3000 provinces read in about a third of a second, and a map mode switched in about half a millisecond. Up to 65,536 provinces fit.

Ray tracing

Reflections of what the camera can't see

Traced on the graphics card against every mesh in the world, moving ones too: the car behind yours shows in its paint. On NVIDIA RTX, AMD RX 6000 and newer, and Intel Arc; on any other card the game falls back by itself.

MeasuredThe whole 1080p view as a mirror costs a quarter of a millisecond more than screen-space reflections on the test machine.

Multiplayer

32 players, and the game goes on when the host goes.

Turn it on, and when the host quits or drops out, the player next in line takes over with the world as it was on their screen while everyone else is back in their place within moments. The co-op template has it on.

Tested with 32 at once: Everyone joining in under a second, and the 33rd told it's full.
Voice chat, no service to pay for: Over the game's own session, with background noise taken out before anything is sent: about 3 KB a second for each player talking.

Releases

How a game goes through Flux

Five steps, all of them in Flux 1.1.38 today.

01
New game
Start from the base template or one of seven more. The launcher and one command make the same game, with its flux.cfg.
02
Frameworks
Turn on what the game needs from 26 frameworks. A game carries only those, and each brings its own checks.
03
Release check
About 30 checks on the release build itself. The game's smoke test plays that build, held to its performance budgets.
04
Build stages
From development to approved release. Only an approver sends a build out of the team, and each approval is signed over the build's files.
05
Updates
Flux Launcher shows an update before it changes anything, runs the game's tests before and after the move, and can roll it back.

Release CheckChecking 1 of 10

RUNThe game has a name of its own
...The game has an icon of its own
...The game opens on a scene that is there
...Every script compiles
...Every scene and resource has what it uses
...The game is pinned to this engine build
...Every addon in the build brings its licence
...The build holds no tests and nothing secret
...The build starts and quits cleanly
...The build passes the game's smoke test

Ten of its checks, as a game fresh from a template meets them: it passes, with one warning.

It checks the build that goes out

The check makes the release build itself, reads back what went into it and plays it with the game's own smoke test, so what passed is what gets uploaded. A template game's build plays its whole test in 2 to 10 seconds.

Approvals that can't be faked

Each approval is signed with the approver's key over the exact build files. A record edited by hand, or a mark by someone taken off the list, shows in red as not signed.

Each framework brings its own checks

A game carries only the checks of what it uses, and a studio can add checks for its own game the same way.

Inside every build

Based on: Godot Engine 4.7.2, plus twelve small patches and one module
Build: 4.7.2-flux-1.1.20: the editor and the Windows export templates, shipped together
Languages: GDScript, C# in the .NET edition, C through flux-c, C++ from the editor
Crashes: A backtrace in release builds too, on every thread
Frameworks: 26 addons on wpd_core 2.7.0, each turned on per game
Launcher: Flux Launcher 1.19.1, a Windows installer that needs no administrator
Tested: 1879 automated checks on the frameworks; 191 reference scenes on each of three renderers

Everything in Flux, framework by framework

Flux Launcher 1.19.1 on its Projects page: template games by Wrenchy Productions, each pinned to 4.7.2-flux-1.1.20, with Run, Open, Release check and Test build beside each.

Every game in one list, with its studio, its pinned build and any warnings.

Saw "Made with Flux" in a game's credits?

That game was built on Flux, the engine every studio Wrenchy Productions publishes shares. Every template's credits screen carries the line next to Godot's licence.

How a studio gets Flux

Flux is not a public download. A studio gets it, with Flux Launcher, by being published by Wrenchy Productions. To talk about publishing, write to [email protected].

Email Wrenchy Productions What comes with Flux

Based on Godot Engine

Flux is based on Godot Engine 4.7.2, which is free and open source under the MIT licence. Godot's licence and copyright lines stay in every Flux build, and so do its contributors' credits.

The licences