Player Profile: Phiality

Hey, I'm Filip Bakreski

I write code and put it on the internet. People seem to like it.

Wine, Proton, Linux graphics stack, and AI systems engineering. Sydney, AU.

Self-proclaimed hoster of things Vercel would charge a mortgage for.

Featured Work Contact Me

Inventory

Python

JavaScript

React

Node.js

AI/ML

Linux

Featured Work

Achievement: MoCoLinux

Several World Firsts

MoCoLinux: Modern Cooperative Linux

A port of coLinux (i386, unmaintained since ~2011) to x86-64: a modern Linux 7.1.5 kernel running as a guest inside Windows XP x64 through Windows 10 x64 on bare hardware, with no hypervisor, no emulation, no virtualization extensions. Both kernels run at ring 0 on the bare processor, world-switching the full CPU context through a passage page mapped identically in both address spaces. It is the first coLinux-style kernel to run an SMP Linux guest, the first with hardware-accelerated OpenGL on the host's real GPU by default, and the first 64-bit Cooperative Linux, with KDE Plasma applications appearing as native Windows windows on the shared desktop and taskbar.

Ring 0Both Kernels, No Hypervisor

1.98xTwo-vCPU SMP Scaling

602fps on the Host GPU (glbench, GT 730)

4Windows Hosts, XP x64 to 10, One Binary

Manjaro Linux with KDE Plasma running as native windows on Windows 8.1 x64, fastfetch reporting virgl on the GeForce GT 730 — One machine, two kernels: Konsole, Kate and KDE Info Center sharing the Windows 8.1 desktop with cmd.exe, and fastfetch reporting Linux 7.1.5 and virgl on the GT 730.

View on GitHub

World Switch at Ring 0

No guest-physical address space, no shadow page tables, no VT-x. A world switch swaps the full CPU context (CR0 to CR8, GDT, IDT, TR, per-CPU MSRs, FPU state) between Windows and Linux through a passage page valid mid-crossing, including the CR4-before-CR3 and MSR_TSC_AUX fixes that keep Windows 10's KVA Shadow and PatchGuard happy.

First Cooperative SMP Guest

Upstream coLinux never got past one CPU. MoCoLinux runs a two-vCPU SMP guest on Windows 10 (posted per-vCPU interrupt bitmaps with targeted DPC doorbells instead of a fake APIC), measuring near-linear 1.98 to 2.03x scaling on sysbench and OpenSSL, with real core topology from CPUID.

Hardware GPU by Default

virtio-gpu over a trapless transport (3 µs median submission round trip) into virglrenderer replaying the guest's GL onto the host card via WGL. CoPresent carries presentation inside the virgl command stream, so sandboxed clients need zero configuration: Firefox renders direct and Steam logs CoPresent active from inside pressure-vessel.

FragRAM: Scattered Pages, Dense Guest RAM

The guest no longer needs contiguous physical runs: the driver allocates whatever scattered nonpaged pages Windows can spare and p2m/m2p tables present them to Linux as ordinary dense RAM starting at pseudo-physical zero, with configurations supported up to 128 GB.

Achievement: Battlefield 2042 Game Services

Game Preservation

Battlefield 2042 Private Game Services

A from-scratch replacement for the online services Battlefield 2042 talks to, so the game keeps working after EA retires its own. With EA unreachable, the client boots to a fully populated menu, matchmakes, gets seated by my Blaze server on a dedicated server running as a second copy of the game, and plays a full Breakthrough match against 60 AI bots. Rank, XP, currency, loadouts and quests persist between runs. Every reply is built from a domain model and serialized, never replayed from a capture: rename a persona and the Blaze login, the gRPC identity reply and the OAuth token all change together.

4Protocol Surfaces Served

653Blaze Classes Dumped from the Client

47/47gRPC Calls Byte-Exact

21,143Preserved Records, All Round-Trip Exact

Battlefield 2042 running on Linux against the private server: menu, matchmaking and a Breakthrough match, with the server log scrolling below — Menu to matchmaking to a live match, on Linux, with my server's log scrolling underneath. Sped up.

Construct, Never Replay

A byte log reproduces exactly one session, for one account, on one map. So HTTP/1.1, HTTP/2, gRPC and Blaze Fire2 replies are all serialized from one model. Captures are ground truth for tests only: decode, re-encode, compare bytes.

Schema Read Out of the Client

A TDF union inside a list is byte-identical to a struct on the wire, so a schema is mandatory. The client's own type registry was dumped from memory: 653 classes, 9 unions, 22 bitfields and 100 enums, closing over itself with zero undefined references.

Protobuf Without the .proto

EA ships no descriptors. Reading the decrypted image out of /proc/<pid>/mem under Proton, field names came from the client's debug printers and field numbers from its parsers' tag compares: 585 messages and 1,786 fields recovered.

A Dedicated Server from a Second Client

The server simulation is compiled into the client, so the player's instance spawns a copy of itself in dedicated mode. It logs in to Blaze, waits in the game pool, and hosts the match over the game's own UDP transport when a player matchmakes.

Achievement: Script Hook Wildlands

ScriptHookV for Wildlands

GRW ScriptHook

A ScriptHookV equivalent for Ghost Recon Wildlands. It loads as a dinput8.dll proxy, exposes a plain C ABI, and loads .asi plugins the way ScriptHookV does: vehicle spawning, teleports, health, the camera, bullet hit and fire events, and the engine's own UI. The engine has no scripting layer, no console and no exported hooks, so every capability is a specific function or field found by decompiling the game in Ghidra and verified in a running game. Other modders now ship plugins and forks built on it.

2,067Unique Downloads on Nexus

240Calls in the C API

65Vehicles Catalogued by Hand

10Plugins in the Repo

Ghost Recon Wildlands in first person, firing a suppressed rifle at a van, using the first person plugin built on the ScriptHook — First person in a game that never had it, one of the plugins in the repo.

Get it on Nexus Source on GitHub API Reference

static void OnHit(const ShHit *hit, void *user) {
    ShVec3 up = hit->pos;
    if (hit->kind != SH_KIND_VEHICLE) return;
    up.z += 90.0f;
    ShPlaceEntity(hit->root, &up, NULL);
}

while (!ShIsInGame() || !ShHitHookInstall()) Sleep(500);
ShOnHit(OnHit, NULL, 0);

Found in Ghidra, Proven Live

Health and stats sit in obfuscated storage, the camera needs per-field ownership, and the close-range blur is one hidden byte. Every engine address is stored as an RVA and resolved against the module base, so ASLR and game updates are survivable.

One Event per Bullet

A projectile is stepped every frame and its hit list accumulates, so acting on the first hit puts you on a fence post. The API holds each bullet and reports the impact that actually stopped it, with the entity root already resolved.

The Engine's Own UI

Plugins build native widgets in a scene of their own, with keyboard focus and a rebuild after world reloads, and hang submenus off one shared F4 menu. No overlay library, the game draws it.

Game-Thread Safe

Engine calls that take locks deadlock from any thread but the game's. The API marshals them onto the game thread itself, and runs plugin callbacks on a worker it owns, so any call is legal inside one.

Achievement: mt76 Threaded NAPI

Linux Kernel Patch, Acked by Maintainer

Threaded NAPI for the mt76 USB WiFi RX Path

The USB RX path in the mt76 WiFi drivers delivered frames to the network stack with a NULL napi pointer, so it never got GRO (generic receive offload), unlike the DMA-based mt76 drivers. Every TCP segment traversed the stack individually. I reworked the main RX queue to run from a threaded NAPI, which enables GRO and moves RX processing into its own kernel thread, parallelising the datapath. On an mt7921u adapter (2x2, 80 MHz, HE-MCS 11) bulk TCP throughput went from ~380 to ~588 Mbit/s. Lorenzo Bianconi, the mt76 maintainer, suggested the approach and Acked v3.

588Mbit/s RX (was 380)

+55%Throughput Gain

Ackedby the mt76 Maintainer

mt76MediaTek WiFi Driver

View Patch on lore.kernel.org Maintainer Ack

GRO on the USB RX Path

The USB path called mt76_rx_complete() with a NULL napi, taking the netif_receive_skb_list() route with no GRO. Routing the main queue through napi_gro_receive() lets the stack coalesce TCP segments before they climb the stack, which is where the bulk-traffic cost was.

Threaded NAPI Datapath

The URB completion handler schedules the NAPI; its poll drains the URBs, builds the skbs, resubmits, and delivers through GRO. Running it threaded moves RX into its own kernel thread so the datapath runs in parallel with the rest of the driver.

No New Struct Fields

Reused mt76_dev's existing napi_dev and napi[] rather than adding state, on a dummy netdev. The MCU queue stays on the existing RX worker. Minimal footprint, which is what got it through review in three rounds.

Measured on Real Hardware

Benchmarked on an mt7921u USB adapter at HE-MCS 11 (2x2, 80 MHz), bulk TCP over multiple streams. The threaded NAPI averaged ~588 Mbit/s against ~380 for the unmodified driver, with the non-threaded variant in between at ~424.

Achievement: Photoshop on Linux

Featured on Phoronix

Adobe Photoshop on Linux via Wine

Patched Wine's MSXML3 and MSHTML to enable Adobe Creative Cloud installers and Photoshop 2021/2025 to run on Linux, closing a 12-year-old bug. Featured in two Phoronix articles and merged into Wine-Staging 11.1.

420+GitHub Stars

2xPhoronix Articles

11.1Wine-Staging Release

12Year-Old Bug

All that just to be called a "redditor."

Read on Phoronix

Linux Native

Photoshop 2021 runs "butter smooth" on Linux, with minor Wayland drag-n-drop issues remaining.

Wine Core Patches

Fixed long-standing MSXML3 and MSHTML incompatibilities blocking Adobe installers.

Upstream Integration

Patches merged into Wine-Staging 11.1 for community testing, pending upstream Wine.

Covered Twice by Phoronix

The initial Creative Cloud installer fix and the Photoshop 2025 follow-up each got their own Phoronix article.

Achievement: AlphaEvolve Verification

Cited in IEEE Access 2026

AlphaEvolve Verification

Verified DeepMind's AlphaEvolve 48-multiplication algorithm for 4×4 complex matrices in Python when it came out and pushed the implementation to GitHub. Picked up as the cited verification reference in Napoli's IEEE Access 2026 paper on the first VLSI hardware implementation of the algorithm, and again in his LASCAS 2026 conference paper.

GitHub repo: PhialsBasement/AlphaEvolve-MatrixMul-Verification

48Multiplications Verified

4×4Complex Matrix Dimension

56 yrsSince Strassen's Rank-49

136GitHub Stars

Read the IEEE Access Paper Verification Repo

Achievement: WineOpenXR Time Conversion

Fixed VR in MSFS 2020 on Linux

ValveSoftware/Proton: WineOpenXR Time Conversion

Implemented the XR_KHR_win32_convert_performance_counter_time OpenXR extension inside Proton's wineopenxr layer. VR controller tracking in Microsoft Flight Simulator 2020 depends on its QPC↔XrTime conversion functions, which were unimplemented, so controllers spawned locked to the HMD position. My patches made MSFS 2020 VR fully playable on Proton for the first time.

#37All-Time Proton Rank

2PRs Merged by Valve

184Lines of C Shipped

2OpenXR Funcs Implemented

Microsoft Flight Simulator 2020 VR running on Linux via Proton after the wineopenxr fix

PR #9347: Implementation PR #9372: Clock Offset Fix

QPC ↔ XrTime Conversion

Implemented both xrConvertWin32PerformanceCounterToTimeKHR and xrConvertTimeToWin32PerformanceCounterKHR, called every frame by VR titles for pose timing.

Overflow-Resistant Math

Diagnosed and fixed a ~15-minute session freeze caused by intermediate integer overflow in the time conversion; rewrote the formula to split seconds and remainder for precision at any frequency.

Clock Domain Correction

Follow-up patch (#9372) added per-call NtQueryPerformanceCounter/CLOCK_MONOTONIC offset computation so QPC and the OpenXR runtime's timeline stay aligned even when epochs differ.

Shipped in Proton Experimental

Both commits were reviewed and merged by Valve maintainer gofman, landed in Proton Experimental (bleeding-edge), then made it into Proton main, shipping to every Steam Deck and Linux gamer running VR titles.

Achievement: The Crew 2 on Linux

First to run The Crew 2 on Linux

The Crew 2 on Linux via Wine

The Crew 2 had been unsupported on Linux for seven years since launch. Uplay DRM, BattlEye, and an opaque crash whenever the .NET-based d3dgear64 recording overlay touched Wine made it one of the more stubborn Ubisoft titles in the Proton compatibility queue. I published the first working Linux launch procedure on r/linux_gaming, where the post drew 84K views, 163 upvotes, and a long comment thread of users I walked through their individual proton logs, including a regression I tracked down to a specific Proton Experimental build from Dec 22.

84KReddit Views

163Upvotes

7 yrsUnsupported on Linux

1stDocumented Working Setup

The Crew 2 running on Linux, screenshot from the r/linux_gaming post

Read on r/linux_gaming

DLL Override Chain

Identified the precise Wine DLL override sequence: uplay_r1_loader64=n,b (native+builtin), d3dgear64=d (disabled, the recording overlay was the silent crasher), and atiadlxx/atiadlxy=b.

Proton Regression Hunt

Tracked a TC2-crashing regression to a specific Proton Experimental build (Dec 22) and identified GE-Proton10-26 as the working version. Helped users downgrade via the in-thread debug sessions.

Live Community Debug

Read users' proton logs in real time and diagnosed individual failures: wrong-exe targeting (the BattlEye launcher vs the game binary), file-hash mismatches, and missing DLL forces. The thread became a working troubleshooting wiki.

Offline-Mode Save Continuity

Documented the offline save format and the Documents/The Crew 2/Save/<AccountId>/ path so existing players could carry their progress over to the Linux launch.

Achievement: Exfilzone on Linux

One-Character Fix

Contractors Showdown Exfilzone on Linux

Wine's belauncher.exe failed to launch any BattlEye-protected title whose BELauncher.ini specified a Win32 root-relative path (one starting with \) for 64BitExe=. The guard in programs/belauncher/main.c only prepended the install directory when PathIsRelativeW(game_exeW) returned TRUE. Per the kernelbase implementation, PathIsRelativeW returns FALSE for any path starting with \, so root-relative paths fell through with no prefix, CreateProcessW was handed a bogus current-drive path, and the launcher exited with error 2. Diagnosed from WINEDEBUG=+belauncher traces and patched upstream against ValveSoftware/wine. Third instalment in the Linux-gaming fix string (after The Crew 2 and MSFS 2020).

BattlEyeSubsystem Patched

3rdIn the Fix Series

May 2026Diagnosed & Patched

Contractors Showdown Exfilzone running on Linux after the BELauncher.ini path fix

ValveSoftware/wine PR #331 Read on r/linux_gaming

WINEDEBUG Diagnosis

Traced via WINEDEBUG=+belauncher that launch_cmd was built without the install-dir prefix, even though path was known one trace line earlier. CreateProcessW got handed a current-drive path that did not exist and bailed with error 2.

Root Cause in kernelbase

programs/belauncher/main.c only prepends the install dir when PathIsRelativeW(game_exeW) is TRUE. But PathIsRelativeW (per dlls/kernelbase/path.c) returns FALSE for any path starting with \, so Win32 root-relative paths fell straight through the guard.

Minimal Wine Patch

Strips the leading backslash (via memmove, with a UNC-path safeguard) so game_exeW stays consistent for the downstream install-dir prepend. PR open upstream at ValveSoftware/wine#331. Once merged, every BattlEye title with a root-relative 64BitExe= just works under Proton.

User Workaround (Until Merged)

Edit BELauncher.ini and strip the leading backslash from 64BitExe=. Works on any Proton build that ships BattlEye. Caveat: Steam's "Verify integrity of game files" overwrites it, so the edit has to be re-applied after every verify pass.

Viral Project

Trophy: Chain of Recursive Thoughts

2,300+ Stars

Chain of Recursive Thoughts

A prompt-loop pattern: the model drafts an answer, critiques it, and regenerates, repeating until the self-score stops improving. Around 200 lines of Python, built on plain prompting. Hit #2 on HackerNews in May 2025 and drew 185+ comments debating whether it's a real technique or a reframing of "try again." I'll let you decide.

2,323GitHub Stars

124Forks

#2Peak HN Rank

185+HN Comments

View Project on GitHub View on HackerNews

Self-Critique Loop

The model drafts, scores its own answer, then regenerates, repeating until it stops improving.

Plain Prompting

Structured prompts and a loop, in ~200 lines of Python.

Divisive on HN

Some called it elegant, others called it "just try again harder." Either way, it hit #2 and held the front page.

Star Trajectory

From ~20 to 2,300+ stars within days of the HN post.

Projects

MoCoLinux

World Firsts

Modern Cooperative Linux: a 2026 kernel running inside Windows XP x64 through 10 x64 at ring 0, with no hypervisor and no VT-x. First 64-bit coLinux, first SMP guest, first with hardware-accelerated OpenGL on the host GPU by default.

C Linux Kernel Windows Internals virgl

BF2042 Game Services

Game Preservation

A private replacement for EA's Battlefield 2042 backend. The game boots, matchmakes and plays full matches on a dedicated server with no EA servers involved, and progression persists between runs.

Python Blaze gRPC HTTP/2 Reverse Engineering