A community-built multiplayer framework for L.A. Noire: injected client, authoritative server, scriptable server-side resources. 1947 Los Angeles, with other people in it.
—
Servers online
—
Players online
—
Player peak
The master list is live and waiting for the first host.
There was no dormant netcode to switch on, no cut lobby to restore, and no leftover replication waiting in the executable.
Nobody at Rockstar or Team Bondi built a multiplayer mode for L.A. Noire. The game shipped in 2011 as a single detective in a city of scripted strangers, and it was never asked to be anything else. Fourteen years of wishing did not change that.
Every system here was found by reading what the shipped game already does — the reflection layer it uses to talk to itself, the developer menu Team Bondi left wired up behind a debug flag, the animation graph that walks its own detectives down Wilshire — and then asking that machinery to do something nobody asked it to do.
What came out is a framework rather than a game mode: an injected client, an authoritative server, and script resources you write yourself. The roleplay does not ship with it. That part is yours to write, and the city was always big enough for it.
Free, non-commercial, and open about how it works — including about the parts that do not work yet.
Evidence
Other players are not sliding props. Each one drives a persistent body that the game itself paths and animates — walk, jog, run — through the same locomotion the story characters use.
Bodies built at runtime, moved by the game's own AI
Locomotion path
677 animation sets
input
local client
server
30 Hz authority
snapshot
over the wire
body
built at runtime
no preallocated pool — the engine's own actor factory builds each one
A face editor that runs while the game does: 26 shape controls, skin tone, hair and beard, built on the fly and streamed straight into the engine. No repacked game archives, and no two detectives alike.
The whole map in free roam, 427 of Team Bondi's own location bookmarks, districts switched live, and the studio's internal developer menu wired into an in-game panel.
A Node.js server with a resource system in the shape FiveM taught everyone to expect: drop a folder in, hook the events, add commands. What the roleplay is, is yours to write.
For developers
The server is plain TypeScript on Node 22 with no build step and no dependencies. A resource is a folder with an index.ts that exports init; the api it is handed carries the events, the characters, the world clock, vehicles and server-owned actors.
55 calls and events · Written against the interface the server actually exposes.
resources/precinct/index.ts
1
import { arg, API_VERSION, type ResourceApi, type ResourceManifest } from "#server";
2
3
export const manifest = { api: API_VERSION } satisfies ResourceManifest;
4
5
export function init(api: ResourceApi) {
6
api.on("playerJoined", ({ player }) => {
7
api.broadcast(`${player.name} signed in at the precinct.`);
8
});
9
10
// Store by identity, never by name: it survives reconnects and renames.
11
api.on("appearanceChanged", ({ player, look }) => {
12
api.saveLook(player.identity, player.name, look);
13
});
14
15
// The schema names and parses the arguments; the handler gets them typed.
16
api.command("goto", { args: [arg.num("x"), arg.num("y"), arg.num("z")] },
17
(player, { x, y, z }) => api.teleport(player.id, { x, y, z }));
18
19
// One clock for everyone; the engine reads the hour every frame.
20
api.setTimeOfDay(23.5);
21
api.setTimeRatio(0);
22
}
The list
Every server announces itself to the master list. Search it, filter it by language, and take the connect line straight into the game.
Nobody is listed right now. Hosting one is a Node server, a single forwarded UDP port, and --announce to appear here.
Read the docsWhere this is going
The launcher is live and keeps itself current, and testers are playing on it. This is what is finished, what is being fought with right now, and what comes next.
An ASLR-safe x86 client injects into the retail game and draws its own overlay over the engine's D3D9 and D3D11 paths.
The engine's reflection layer and Team Bondi's internal developer menu wired into an in-game panel. Live case switching: free roam reaches an empty world in four seconds.
Remote players drive real bodies that the game paths and animates. The runtime face editor is synced over the wire and persisted.
Vehicle sync and weapons are in and imperfect; seeing a player fire does not yet mean the damage landed. This is the open work, and it is open while the build is out.
One executable a player keeps, signed releases behind it, and a master list servers announce themselves to. Live for testers since 8 September 2026; an open release waits on phase 4.
The precinct
Testers get the build, and the Discord is where they are found. The dev log carries what got built this week; run /apply if you want in while it is still small.
Run /apply in the Discord and answer four short questions. Accepted testers get the Tester role, the testing area, and the launcher channel the builds land on.
Not an English reader?
EnglishTürkçeDeutschРусскийEspañolPortuguêsFrançaisPolski
Every announcement is translated, and each language has its own channels.
Stick around and you get ranked
Messages sent in the server.
Questions
Yes. You need your own copy of L.A. Noire (2011) on PC — the Steam build is what this is developed against. Nothing here ships game files, and there is no piracy support.
Through the launcher, and through the Discord. NoireMultiplayer.exe updates your game folder and starts the game on the server you pick, but the servers are the tester group's while vehicles and combat are still rough — so run /apply in the Discord first. There is no separate installer and no injection step to run yourself.
L.A. Noire has no online component and no anti-cheat, so there is nothing to be banned from. The mod is injected at runtime and does not modify your game files.
It is a free, non-commercial fan project, not affiliated with or endorsed by Rockstar Games or Team Bondi. No paid features, no sales, no donations tied to access.
Nothing caps it structurally. Player ids are 16-bit, so the wire addresses tens of thousands, and bodies are no longer drawn from a preallocated pool — they are built at runtime through the engine's own actor factory, so spawning thousands of them is not the problem it used to be. What nobody has done yet is put thousands of players behind those bodies. The 32 in the server's --max flag is a comfortable default, not a limit, and every number on this page is untested at scale.
Testers can. The server is plain TypeScript on Node 22 with no build step and no runtime dependencies: forward one UDP port, run it, and pass --announce if you want it listed here. The API reference covers writing your own resources.
Yes. Testers, server scripters, translators and people who just report bugs properly are all useful. Start in the Discord.