@mizius/minecraft 0.0.0-stage → 1.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/update.js ADDED
@@ -0,0 +1,376 @@
1
+ import { createHash, randomUUID } from 'node:crypto';
2
+ import { execFile, spawn } from 'node:child_process';
3
+ import { createWriteStream } from 'node:fs';
4
+ import { cp, mkdir, mkdtemp, readFile, realpath, rename, rm } from 'node:fs/promises';
5
+ import os from 'node:os';
6
+ import path from 'node:path';
7
+ import { Readable, Transform } from 'node:stream';
8
+ import { pipeline } from 'node:stream/promises';
9
+ import { promisify } from 'node:util';
10
+ const execFileAsync = promisify(execFile);
11
+ const releaseApiUrl = 'https://api.github.com/repos/miziusLabs/Minecraft/releases/latest';
12
+ const stableVersionPattern = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
13
+ const releaseTagPattern = /^v(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
14
+ class NotGlobalInstallationError extends Error {
15
+ }
16
+ class RestoreFailedError extends Error {
17
+ }
18
+ function errorMessage(error) {
19
+ return error instanceof Error ? error.message : String(error);
20
+ }
21
+ function reportProgress(options, message) {
22
+ try {
23
+ options.progress?.(message);
24
+ }
25
+ catch { /* Reporting must not change update results. */ }
26
+ }
27
+ async function removeTemporary(directory) {
28
+ try {
29
+ await rm(directory, { recursive: true, force: true });
30
+ }
31
+ catch { /* A cleanup failure must not hide the update result. */ }
32
+ }
33
+ function processErrorMessage(error) {
34
+ const detail = error;
35
+ return detail.stderr?.trim() || errorMessage(error);
36
+ }
37
+ function encodePowerShell(script) {
38
+ return Buffer.from(script, 'utf16le').toString('base64');
39
+ }
40
+ async function runProcess(executable, args, timeoutMs) {
41
+ return await new Promise((resolve, reject) => {
42
+ const child = spawn(executable, args, { windowsHide: true, stdio: ['ignore', 'pipe', 'pipe'] });
43
+ const stdout = [];
44
+ const stderr = [];
45
+ let outputSize = 0;
46
+ let timedOut = false;
47
+ let overflow = false;
48
+ let killFinished;
49
+ const stopTree = () => {
50
+ if (!child.pid)
51
+ return Promise.resolve();
52
+ if (process.platform !== 'win32') {
53
+ child.kill('SIGTERM');
54
+ return Promise.resolve();
55
+ }
56
+ return new Promise(resolveKill => {
57
+ const killer = spawn('taskkill.exe', ['/PID', String(child.pid), '/T', '/F'], {
58
+ windowsHide: true,
59
+ stdio: 'ignore',
60
+ });
61
+ killer.once('error', () => resolveKill());
62
+ killer.once('close', () => resolveKill());
63
+ });
64
+ };
65
+ const timer = setTimeout(() => {
66
+ timedOut = true;
67
+ killFinished = stopTree();
68
+ }, timeoutMs);
69
+ const append = (target, chunk) => {
70
+ outputSize += chunk.length;
71
+ if (outputSize > 10 * 1024 * 1024 && !overflow) {
72
+ overflow = true;
73
+ killFinished = stopTree();
74
+ }
75
+ target.push(chunk);
76
+ };
77
+ child.stdout.on('data', (chunk) => append(stdout, chunk));
78
+ child.stderr.on('data', (chunk) => append(stderr, chunk));
79
+ child.once('error', error => {
80
+ clearTimeout(timer);
81
+ reject(error);
82
+ });
83
+ child.once('close', async (code, signal) => {
84
+ clearTimeout(timer);
85
+ if (killFinished)
86
+ await killFinished;
87
+ const output = Buffer.concat(stdout).toString('utf8');
88
+ if (timedOut) {
89
+ reject(new Error(`${executable} did not finish within ${timeoutMs} milliseconds.`));
90
+ }
91
+ else if (overflow) {
92
+ reject(new Error(`${executable} produced more than 10 MB of output.`));
93
+ }
94
+ else if (code !== 0) {
95
+ const detail = Buffer.concat(stderr).toString('utf8').trim();
96
+ reject(new Error(detail || `${executable} exited with code ${code ?? signal ?? 'unknown'}.`));
97
+ }
98
+ else {
99
+ resolve(output);
100
+ }
101
+ });
102
+ });
103
+ }
104
+ async function runNpm(args, timeoutMs) {
105
+ try {
106
+ if (process.platform !== 'win32')
107
+ return (await runProcess('npm', args, timeoutMs)).trim();
108
+ const encodedArgs = Buffer.from(JSON.stringify(args), 'utf8').toString('base64');
109
+ const script = [
110
+ "$ErrorActionPreference = 'Stop'",
111
+ "$npmArguments = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('" + encodedArgs + "')) | ConvertFrom-Json",
112
+ '$npmCommand = Get-Command npm.cmd -ErrorAction Stop',
113
+ '& $npmCommand.Source @npmArguments',
114
+ 'exit $LASTEXITCODE',
115
+ ].join('; ');
116
+ return (await runProcess('powershell.exe', [
117
+ '-NoProfile', '-NonInteractive', '-EncodedCommand', encodePowerShell(script),
118
+ ], timeoutMs)).trim();
119
+ }
120
+ catch (error) {
121
+ throw new Error(`npm ${args[0] ?? 'command'} failed. ${processErrorMessage(error)}`, { cause: error });
122
+ }
123
+ }
124
+ export function createNpmAdapter(prefix) {
125
+ const prefixArgs = prefix ? ['--prefix', path.resolve(prefix)] : [];
126
+ return {
127
+ async globalRoot() {
128
+ const output = await runNpm(['root', '--global', ...prefixArgs], 15_000);
129
+ if (!output)
130
+ throw new Error('npm did not return its global package directory.');
131
+ return path.resolve(output);
132
+ },
133
+ async install(tarball) {
134
+ await runNpm([
135
+ 'install', '--global', '--ignore-scripts', '--no-audit', '--no-fund',
136
+ ...prefixArgs, tarball,
137
+ ], 300_000);
138
+ },
139
+ };
140
+ }
141
+ function stableParts(version) {
142
+ if (!stableVersionPattern.test(version))
143
+ return undefined;
144
+ return version.split('.').map(BigInt);
145
+ }
146
+ export function isNewerVersion(candidate, current) {
147
+ const candidateParts = stableParts(candidate);
148
+ const currentParts = stableParts(current);
149
+ if (!candidateParts || !currentParts)
150
+ return false;
151
+ for (let index = 0; index < candidateParts.length; index++) {
152
+ if (candidateParts[index] > currentParts[index])
153
+ return true;
154
+ if (candidateParts[index] < currentParts[index])
155
+ return false;
156
+ }
157
+ return false;
158
+ }
159
+ async function readPackageMetadata(packageRoot) {
160
+ return JSON.parse(await readFile(path.join(packageRoot, 'package.json'), 'utf8'));
161
+ }
162
+ function samePath(left, right) {
163
+ const normalizedLeft = path.resolve(left).replace(/[\\/]+$/, '');
164
+ const normalizedRight = path.resolve(right).replace(/[\\/]+$/, '');
165
+ return process.platform === 'win32'
166
+ ? normalizedLeft.toLocaleLowerCase('en-US') === normalizedRight.toLocaleLowerCase('en-US')
167
+ : normalizedLeft === normalizedRight;
168
+ }
169
+ async function resolveGlobalPackageRoot(packageRoot, npm) {
170
+ const globalRoot = await npm.globalRoot();
171
+ const globalPackage = path.join(globalRoot, '@mizius', 'minecraft');
172
+ if (samePath(packageRoot, globalPackage))
173
+ return globalPackage;
174
+ try {
175
+ const [currentPath, globalPath] = await Promise.all([realpath(packageRoot), realpath(globalPackage)]);
176
+ return samePath(currentPath, globalPath) ? globalPath : undefined;
177
+ }
178
+ catch (error) {
179
+ if (error.code === 'ENOENT')
180
+ return undefined;
181
+ throw error;
182
+ }
183
+ }
184
+ function validReleaseTag(tag) {
185
+ return typeof tag === 'string' && releaseTagPattern.test(tag);
186
+ }
187
+ function releaseAsset(release, tag, apiUrl) {
188
+ if (release.draft === true || release.prerelease === true)
189
+ throw new Error('GitHub returned a draft or prerelease as the latest release.');
190
+ if (!Array.isArray(release.assets))
191
+ throw new Error('GitHub release metadata has no asset list.');
192
+ const asset = release.assets.find((item) => item?.name === 'minecraft.tgz');
193
+ if (!asset || asset.state !== 'uploaded')
194
+ throw new Error('The latest GitHub release has no uploaded minecraft.tgz asset.');
195
+ if (typeof asset.digest !== 'string' || !/^sha256:[0-9a-f]{64}$/i.test(asset.digest)) {
196
+ throw new Error('The latest GitHub release does not provide a valid SHA-256 asset digest.');
197
+ }
198
+ if (!Number.isSafeInteger(asset.size) || asset.size <= 0 || asset.size > 100_000_000) {
199
+ throw new Error('The latest GitHub release asset has an invalid size.');
200
+ }
201
+ if (typeof asset.browser_download_url !== 'string')
202
+ throw new Error('The latest GitHub release asset has no download URL.');
203
+ const downloadUrl = new URL(asset.browser_download_url);
204
+ const apiHost = new URL(apiUrl).hostname;
205
+ const apiIsSecure = new URL(apiUrl).protocol === 'https:';
206
+ const allowedHost = downloadUrl.hostname === 'github.com' || (!apiIsSecure && downloadUrl.hostname === apiHost);
207
+ const expectedPath = `/miziusLabs/Minecraft/releases/download/${tag}/minecraft.tgz`;
208
+ if (downloadUrl.protocol !== (apiIsSecure ? 'https:' : 'http:') || !allowedHost
209
+ || downloadUrl.pathname.toLowerCase() !== expectedPath.toLowerCase()) {
210
+ throw new Error('The latest GitHub release asset has an unexpected download URL.');
211
+ }
212
+ return {
213
+ url: downloadUrl.href,
214
+ sha256: asset.digest.slice('sha256:'.length).toLowerCase(),
215
+ size: asset.size,
216
+ };
217
+ }
218
+ async function latestRelease(apiUrl) {
219
+ const response = await fetch(apiUrl, {
220
+ headers: { Accept: 'application/vnd.github+json', 'User-Agent': 'mizius-minecraft-cli' },
221
+ signal: AbortSignal.timeout(5000),
222
+ });
223
+ if (response.status === 404)
224
+ return undefined;
225
+ if (!response.ok)
226
+ throw new Error(`GitHub release lookup returned HTTP ${response.status}.`);
227
+ const release = await response.json();
228
+ if (!release || typeof release !== 'object' || !validReleaseTag(release.tag_name)) {
229
+ throw new Error('GitHub returned an invalid stable release tag.');
230
+ }
231
+ return release;
232
+ }
233
+ async function downloadAsset(asset, target) {
234
+ const temporary = `${target}.${randomUUID()}.tmp`;
235
+ try {
236
+ const response = await fetch(asset.url, { signal: AbortSignal.timeout(120_000) });
237
+ if (!response.ok || !response.body)
238
+ throw new Error(`Release asset download returned HTTP ${response.status}.`);
239
+ const hash = createHash('sha256');
240
+ let size = 0;
241
+ const verify = new Transform({ transform(chunk, _encoding, callback) {
242
+ size += chunk.length;
243
+ if (size > asset.size) {
244
+ callback(new Error('Release asset exceeded the declared size.'));
245
+ return;
246
+ }
247
+ hash.update(chunk);
248
+ callback(null, chunk);
249
+ } });
250
+ await pipeline(Readable.fromWeb(response.body), verify, createWriteStream(temporary, { flags: 'wx' }));
251
+ if (size !== asset.size || hash.digest('hex') !== asset.sha256) {
252
+ throw new Error('Release asset size or SHA-256 digest did not match GitHub metadata.');
253
+ }
254
+ await rename(temporary, target);
255
+ }
256
+ finally {
257
+ try {
258
+ await rm(temporary, { force: true });
259
+ }
260
+ catch { /* Keep the download error or result as the primary outcome. */ }
261
+ }
262
+ }
263
+ async function readTarballMetadata(tarball) {
264
+ try {
265
+ const { stdout } = await execFileAsync('tar', ['-xOf', tarball, 'package/package.json'], {
266
+ encoding: 'utf8', windowsHide: true, timeout: 15_000, maxBuffer: 1024 * 1024,
267
+ });
268
+ return JSON.parse(stdout);
269
+ }
270
+ catch (error) {
271
+ throw new Error(`Could not read package metadata from minecraft.tgz. ${processErrorMessage(error)}`, { cause: error });
272
+ }
273
+ }
274
+ async function restorePackage(target, backup) {
275
+ await rm(target, { recursive: true, force: true });
276
+ await mkdir(path.dirname(target), { recursive: true });
277
+ await cp(backup, target, { recursive: true, errorOnExist: true, force: false });
278
+ }
279
+ async function updateGlobalCli(packageRoot, globalPackageRoot, npm, options) {
280
+ const localMetadata = await readPackageMetadata(packageRoot);
281
+ if (localMetadata.name !== '@mizius/minecraft' || typeof localMetadata.version !== 'string'
282
+ || !stableParts(localMetadata.version)) {
283
+ throw new Error('The installed CLI package has invalid name or version metadata.');
284
+ }
285
+ const previousVersion = localMetadata.version;
286
+ const apiUrl = options.releaseApiUrl ?? releaseApiUrl;
287
+ const release = await latestRelease(apiUrl);
288
+ if (!release)
289
+ return { previousVersion, installedVersion: previousVersion, updated: false };
290
+ const latestVersion = release.tag_name.slice(1);
291
+ if (!isNewerVersion(latestVersion, previousVersion)) {
292
+ return { previousVersion, installedVersion: previousVersion, updated: false };
293
+ }
294
+ const asset = releaseAsset(release, release.tag_name, apiUrl);
295
+ const temporaryRoot = await mkdtemp(path.join(options.temporaryRoot ?? os.tmpdir(), 'mizius-minecraft-update-'));
296
+ const tarball = path.join(temporaryRoot, 'minecraft.tgz');
297
+ try {
298
+ reportProgress(options, `Downloading Minecraft CLI v${latestVersion}.`);
299
+ await downloadAsset(asset, tarball);
300
+ const tarballMetadata = await readTarballMetadata(tarball);
301
+ if (tarballMetadata.name !== '@mizius/minecraft' || tarballMetadata.version !== latestVersion) {
302
+ throw new Error('The downloaded release package name or version does not match its GitHub release.');
303
+ }
304
+ const backupRoot = await mkdtemp(path.join(options.temporaryRoot ?? os.tmpdir(), 'mizius-minecraft-backup-'));
305
+ const backupPackage = path.join(backupRoot, 'package');
306
+ let keepBackup = false;
307
+ try {
308
+ await cp(globalPackageRoot, backupPackage, { recursive: true, errorOnExist: true, force: false });
309
+ try {
310
+ reportProgress(options, `Installing Minecraft CLI v${latestVersion}.`);
311
+ await npm.install(tarball);
312
+ const installedMetadata = await readPackageMetadata(globalPackageRoot);
313
+ if (installedMetadata.name !== '@mizius/minecraft' || installedMetadata.version !== latestVersion) {
314
+ throw new Error('npm installed a package with unexpected name or version metadata.');
315
+ }
316
+ }
317
+ catch (error) {
318
+ try {
319
+ await restorePackage(globalPackageRoot, backupPackage);
320
+ }
321
+ catch (restoreError) {
322
+ keepBackup = true;
323
+ throw new RestoreFailedError(`The update failed and the previous package could not be restored. Recovery copy: ${backupPackage}. ${errorMessage(restoreError)}`, { cause: error });
324
+ }
325
+ throw new Error(`Could not install the update. The previous CLI version was restored. ${errorMessage(error)}`, { cause: error });
326
+ }
327
+ reportProgress(options, `Installed Minecraft CLI v${latestVersion}.`);
328
+ return { previousVersion, installedVersion: latestVersion, updated: true };
329
+ }
330
+ finally {
331
+ if (!keepBackup)
332
+ await removeTemporary(backupRoot);
333
+ }
334
+ }
335
+ finally {
336
+ await removeTemporary(temporaryRoot);
337
+ }
338
+ }
339
+ export async function updateCli(packageRoot, options = {}) {
340
+ const npm = options.npmAdapter ?? createNpmAdapter();
341
+ const globalPackageRoot = await resolveGlobalPackageRoot(packageRoot, npm);
342
+ if (!globalPackageRoot) {
343
+ throw new NotGlobalInstallationError('Self-update requires the documented global npm installation. Install minecraft.tgz with npm install --global.');
344
+ }
345
+ const release = await options.acquireLock?.();
346
+ try {
347
+ return await updateGlobalCli(packageRoot, globalPackageRoot, npm, options);
348
+ }
349
+ finally {
350
+ if (release)
351
+ await release();
352
+ }
353
+ }
354
+ export async function attemptAutomaticUpdate(packageRoot, options = {}) {
355
+ try {
356
+ return { result: await updateCli(packageRoot, options) };
357
+ }
358
+ catch (error) {
359
+ if (error instanceof NotGlobalInstallationError)
360
+ return {};
361
+ return {
362
+ error: error instanceof Error ? error : new Error(String(error)),
363
+ fatal: error instanceof RestoreFailedError,
364
+ };
365
+ }
366
+ }
367
+ export async function relaunchCli(entrypoint, nodeArgs, cliArgs) {
368
+ return await new Promise((resolve, reject) => {
369
+ const child = spawn(process.execPath, [...nodeArgs, entrypoint, ...cliArgs], {
370
+ stdio: 'inherit',
371
+ windowsHide: false,
372
+ });
373
+ child.once('error', reject);
374
+ child.once('close', code => resolve(code ?? 1));
375
+ });
376
+ }
package/package.json CHANGED
@@ -1,6 +1,42 @@
1
1
  {
2
2
  "name": "@mizius/minecraft",
3
- "version": "0.0.0-stage",
4
- "stub": true,
5
- "description": "Temporary package placeholder for staged publishing"
6
- }
3
+ "version": "1.5.0",
4
+ "description": "Launch and control an isolated Minecraft client from the command line.",
5
+ "homepage": "https://github.com/miziusLabs/Minecraft",
6
+ "repository": {
7
+ "type": "git",
8
+ "url": "https://github.com/miziusLabs/Minecraft.git",
9
+ "directory": "cli"
10
+ },
11
+ "type": "module",
12
+ "bin": {
13
+ "minecraft": "dist/index.js"
14
+ },
15
+ "files": [
16
+ "dist/**",
17
+ "artifacts/minecraft-control-*.jar",
18
+ "compatibility.json",
19
+ "skills/minecraft/SKILL.md",
20
+ "README.md"
21
+ ],
22
+ "engines": {
23
+ "node": ">=22"
24
+ },
25
+ "publishConfig": {
26
+ "access": "public"
27
+ },
28
+ "scripts": {
29
+ "build": "node scripts/sync-version.mjs && tsc -p tsconfig.json && node scripts/package-skill.mjs",
30
+ "test": "npm run build && node --test --experimental-strip-types test/*.test.ts",
31
+ "prepack": "npm run build && node scripts/package-mod.mjs"
32
+ },
33
+ "dependencies": {
34
+ "adm-zip": "^0.6.1",
35
+ "tar": "^7.5.23"
36
+ },
37
+ "devDependencies": {
38
+ "@types/adm-zip": "^0.5.7",
39
+ "@types/node": "^22.19.0",
40
+ "typescript": "^5.9.3"
41
+ }
42
+ }
@@ -0,0 +1,64 @@
1
+ ---
2
+ name: minecraft
3
+ description: Launch and control a managed Minecraft Java client with the Minecraft command line tool.
4
+ ---
5
+
6
+ # Minecraft command line
7
+
8
+ Use the `minecraft` command line tool to start and control the managed Minecraft client.
9
+
10
+ ## Start and inspect
11
+
12
+ 1. Run `minecraft versions --json` to see supported versions and the default.
13
+ 2. Start the requested version with `minecraft launch [version] --username Agent --json`. Use a valid offline profile name. The command waits until the game accepts commands.
14
+ 3. If another managed client is already running, inspect it with `minecraft status --json`. Reuse it if it is the requested client. Run `minecraft stop --json` before switching versions.
15
+ 4. Inspect the screen with `minecraft control state --json` or save a screenshot with `minecraft control screenshot --output <file>` before acting.
16
+
17
+ ## Control the client
18
+
19
+ - Use `minecraft control join <server-address>` to connect to a server. Check state and screenshots while the client connects.
20
+ - Use `minecraft control click <x> <y>` to click at screenshot coordinates. The origin is at the top left.
21
+ - Use `minecraft control move <x> <y>`, `minecraft control drag <x1> <y1> <x2> <y2>`, and `minecraft control scroll <amount>` for mouse input.
22
+ - Use `minecraft control key <name> --action press`, `hold`, or `release` for keyboard input. Key names follow GLFW, such as `W`, `LEFT_SHIFT`, `ENTER`, and `ESCAPE`.
23
+ - Use `minecraft control type <text>` to enter text in an open interface. Open chat with `minecraft control key T` before typing chat text, then use `minecraft control key ENTER` to send it.
24
+ - Use `minecraft control execute <command>` only when the current server grants the required permission.
25
+ - Use `minecraft control logs [query]` to inspect recent client log lines.
26
+ - Use `minecraft control record start` before an interaction and `minecraft control record stop` afterward to save a silent MP4 of the game view. The command output contains the recording path. Recordings stop automatically after ten minutes.
27
+ - Use `minecraft control batch <json-array>` to run a short sequence of commands without interleaving another control action.
28
+ - Release held keys and mouse buttons after each movement or interaction. Held inputs expire after 30 seconds without game commands.
29
+ - Treat the client as one shared instance. Do not send overlapping controls from separate agents.
30
+ - After joining a server, opening a menu, or changing screens, inspect state with `minecraft control state` before sending more input.
31
+ - If the client stops responding, inspect its state and screenshot. Restore a minimized window and close blocking screens before retrying.
32
+
33
+ ## Limits
34
+
35
+ The CLI runs an offline profile and does not sign in to a Microsoft account. Servers and Realms that require authenticated online accounts reject this profile. Authentication errors in client logs are expected for those services.
36
+
37
+ The managed client runs on Windows or Linux x64. On Windows, it stores data under `%LOCALAPPDATA%\mizius\Minecraft` by default. Set `mizius_minecraft_home` to use another managed directory.
38
+
39
+ The default window is 1280 by 720 with GUI scale 2 and FOV 90. Sprint uses R. The client mutes master volume and does not pause on focus loss. New instances use the Custom graphics preset, 8 chunk render distance, 5 chunk simulation distance, and a 60 FPS cap. Existing instance settings remain unchanged.
40
+
41
+ Run `minecraft --help` for all commands. The command port defaults to 8765. Use `--port` to select another free port. The CLI reserves port 18765 while it installs, starts, or stops a client.
42
+
43
+ ## Linux setup
44
+
45
+ On Linux, managed data defaults to `$XDG_DATA_HOME/mizius/Minecraft`, or
46
+ `~/.local/share/mizius/Minecraft` when `XDG_DATA_HOME` is unset. The
47
+ `mizius_minecraft_home` override works on both platforms. Linux requires glibc,
48
+ an X11 or Wayland display, OpenGL or Vulkan drivers, and the LWJGL desktop libraries.
49
+ On Ubuntu 24.04, install the desktop dependencies with
50
+ `apt-get install libgl1-mesa-dri libglx-mesa0 libxrandr2 libxcursor1 libxi6 libxinerama1 libasound2t64 libegl1 libopengl0 libvulkan1 mesa-vulkan-drivers`.
51
+ Java downloads automatically. For a headless session, install `xvfb` and keep
52
+ its display server running for the lifetime of the client.
53
+
54
+ ```sh
55
+ Xvfb :99 -screen 0 1280x720x24 -nolisten tcp -noreset > /tmp/minecraft-xvfb.log 2>&1 &
56
+ export DISPLAY=:99
57
+ export XDG_RUNTIME_DIR="${XDG_RUNTIME_DIR:-$(mktemp -d)}"
58
+ export LIBGL_ALWAYS_SOFTWARE=1
59
+ minecraft launch --json
60
+ minecraft control state --json
61
+ ```
62
+
63
+ This uses Mesa software rendering rather than a physical GPU. Minecraft 26.3
64
+ can use software Vulkan when the virtual display cannot provide its OpenGL context.