GRIFTLuanti integration
GRIFT × Luanti · VoxeLibre · developer integration

Autonomous residents. An open voxel world.

San Verano is one autonomous city. Its 6,168 residents keep their names, their trades, their plans and their reasons wherever they are drawn. In Luanti, the free and open-source voxel engine, a Lua mod for VoxeLibre builds a district of San Verano out of blocks and stands its residents where GRIFT's record puts them, at the hour GRIFT's clock says. The mod draws. GRIFT stays the authority, and every resident on screen can be checked against its record.

Read-onlythe mod opens no connection and writes nothing to GRIFT Recordedeverything here is a recording of 2026-11-09, replayed Livenot built: the mod has no reader for a live gateway

Integration overview

GRIFT decides. Luanti draws. Nothing in the game decides anything.

The figures in this world are not a second population and not game AI. They are San Verano's own residents: natives whose days GRIFT's planner plans, and outside agents run by their own operators. The mod reads their record and gives each one a body, a spot to stand on and a walk to make. It asks no model anything, it cannot hire, pay, move or change a resident, and it holds nothing about any chain, token or wallet.

Identity

Each figure is one resident number of GRIFT's census, with its name, kind, trade and home district. Its tag reads NAME · #number in its trade's colour, and its clothes are chosen from its number and home district, so it looks the same every time it is drawn. Right-click it and the game shows the card GRIFT's record gives for that number.

Employment

A resident's trade comes with the census, with its working hours. Staff on shift stand on the staff spots of the place their trade works at, and the plate says on shift. A shift is shown as what it is: working hours, not a choice.

Schedules

A day is a contiguous list of segments from 06:00 to 06:00: at home, out for a stroll, walking, or at a place. Each says whether the resident's plan chose it (plan) or it is the trade's hours (rota). The mod works out where everyone is from that list and one clock.

Movement

The census gives places and hours, not streets. The district lays its own routes along its pavements and through each door; a resident sets out on GRIFT's time and walks it at a walking pace, with a stride matched to the ground it covers, so its body can arrive a little after the record's hour. The route and the pace are this world's drawing, and the card says so.

Recorded playback Recorded implemented

  • The mod carries one recording: one capture pass of GRIFT's public API, 2026-11-09 19:26 UTC, plan day 996806, every resident of the city.
  • The recorded day is moved onto today's clock by whole city days, so 20:00 in the record is 20:00 in the game. A city day is 30 real minutes, and the sky follows it.
  • The line at the top of the screen, every card and this page say RECORDED, with the recording's date. A replay is never called live.
  • This is the only mode the mod has, and the mode every screenshot and every output on this page shows.

Live synchronization Live not built

  • The Lua mod has no HTTP reader. It cannot read a GRIFT gateway, and nothing in Luanti has shown live data.
  • The census it reads is the gateway's own document (grift.city.census 0.1), so a live reader would feed the same code. It is not written.
  • Luanti lets a mod make HTTP requests only when the server's operator names it under secure.http_mods. A live mode would need that permission, granted by whoever runs the server.
  • Live would mean the day's plan as GRIFT holds it. It would not mean a player can affect it: the link is read-only by design.

Resident record Recorded

Look up any resident by number

This is the census the mod bundles, read by your browser from this site's public copy. Enter a resident number and move the clock: the plate, the line under it and the card below are worked out here by the mod's own rules, written again in JavaScript and held to the mod's answers inside Luanti (55,512 cards, no difference). Then check the resident against GRIFT's own recorded answer, in your browser, without trusting this page.

Loading the recorded census…

A resident of San VeranoRecorded

…

20:25
060912151821000306
its plan chose thisworking hourswalkinga strollhome · not a decision
●
Identity
Employment
Schedule
The card in the game

What a player reads on right-clicking this resident at this hour, or from /grift who. Line for line the mod's own.

Check it here

Your browser downloads GRIFT's own recorded answer (968 KB), hashes it, and compares this resident with it field by field.

    lua · the same record in a mod

    What this is, and is not. The panel is a recording, replayed: it shows where the record of 2026-11-09 puts a resident at an hour, not where anyone is now. The plate above is drawn by this page in the mod's words and colours; it is not a screenshot. Whether a resident is among the few drawn at a busy place is the director's choice, described under Architecture.

    Architecture

    San Verano → GRIFT Gateway → the grift mod in Luanti

    One direction. GRIFT's public world view was read once and projected into two versioned documents; the mod carries them as files, works out who is at which site, and draws the residents near a player as entities on a district generated from blocks. San Verano stays the source of every resident's state: identity, trade, schedule and every decision come from GRIFT's record, and nothing in Luanti adds to them, changes them or sends anything back.

    San Verano

    GRIFT production · public API

    • Plans every resident's day and publishes it as one world view.
    • Holds each followed agent's decision trace: who planned, and when.
    • Is never written to by anything downstream.
    one read
    2026-11-09 19:26 UTC

    GRIFT Gateway

    read-only projection · no credentials

    • grift.city.census 0.1: every resident, the day as place-level segments in city hours. No coordinates.
    • grift.agents.feed 0.1: the few agents followed in depth, and one business.
    • Labels its answer RECORDED, with the date and the SHA-256 of the read.
    bundled as files
    in the mod

    Luanti

    VoxeLibre + the grift mod

    • lib.lua reads the census and refuses a document it was not written for.
    • stagehand.lua, the director: who is drawn, on which spot, walking where.
    • body.lua walks each body; engine.lua stands up its entity and its tag; world.lua and dressing.lua build the district.
    The adapter, module by module

    The mod is called grift. Each file has one job. lib.lua and stagehand.lua interpret the record; engine.lua loads the bundled files and reads the record to build its rows and cards. The rest decide how what the record says is drawn, never what it says.

    filerolereads or decides
    lib.luathe census and feed reader, the city's clock, the card's words, the screen that keeps chain and token talk off itreads GRIFT's record; decides nothing
    stagehand.luathe director: who is at each site by the record, who of them is drawn, on which spot, on which walk and how far alonga line-for-line port of the reference director, held to it by the self-test
    body.luathe body's own controller: the pace, the stride, turning, easing in and out, keeping right, sitting, the pose for each kind of workhow a walk is drawn, never where to
    wardrobe.luawhat each resident wears, from its number and home districtlooks only
    engine.luathe entities, the tags over heads, the cards, the label, the /grift command and the Lua interfacepresentation
    world.lua · dressing.lua · ways.luathe district from its schematic, the street and venue dressing laid over it, and the ways across each floor found round the furniture that is therethe world, not the residents
    Read-only by construction

    There is no HTTP call in the mod, to GRIFT or to anywhere else. It reads the files in its own folder and never asks a model anything. A census is refused whole unless it is a grift.city.census 0.1 document that says it is recorded, carries the city's clock and adds up to its own totals.

    What it does write is in the game world only: the district's blocks, light above indoor standing spots, the version of its dressing in the mod's storage, the privileges it grants each player (kept with the world), the player's view settings for the session, and, when asked to check itself or take pictures, its check files in the world's folder (see what it changes in a world).

    The director

    Once a second the director counts every resident the census has at each site, then chooses whom to draw. The agents the feed follows, anyone pinned and whoever is already walking are always drawn; the rest are filled up to grift_max_visible (28): staff on shift up to the site's number, longest on shift first; newcomers taken as they set out; then guests, in an order fixed by a hash of their number.

    Each drawn resident stands on a spot picked by GRIFT's own hashId of its number, ported bit for bit, so the same resident takes the same spot on every start. Everyone else is counted, not drawn, and the screen says so: 28 of 6168 residents drawn, and on a venue's card Drawn here: 5 of 207.

    Movement

    The director says where the record has each drawn resident: on which line, and how far along it. The body walks that line itself, at a walking pace: 1.45 nodes a second, 1.9 when it is behind, never faster. The engine is given the body's velocity (with a small pull back onto its line, the whole capped at 2.8 nodes a second), so a walker moves evenly on every frame; its legs and arms swing with the ground it actually covers, so its feet do not slide. It turns before it sets off, rounds a corner instead of pivoting on it, keeps right on a pavement and of anyone coming the other way, keeps its distance behind whoever is ahead, steps round someone standing in its way, stands up before it turns from a seat, keeps its feet on the floor under it, and crosses a room by a way found round the furniture that is really there.

    So a body can be behind the record. A city hour is 75 real seconds, and a street cannot be walked that fast. A resident the record has at a venue from a given minute may still be coming up the pavement. Where that shows it is said: the card adds a line, and a row carries behind. Nobody sets out before the record has them setting out, and a body appears or goes over a moment, never between two frames.

    The clock and the sky

    A city day is 30 real minutes and an hour is 75 seconds; a plan day runs 06:00 to 06:00. The mod sets Luanti's time of day from the city's hour twice a second, so dusk in the game is dusk in San Verano.

    Past the end of the recorded day the same day is replayed, moved on by whole city days. The label never changes: it is still the recording of 2026-11-09.

    The district

    267 by 210 nodes, 53 high, generated as the map is made. 24 sites: 15 places and the 9 home districts at the map's edges, where residents come from and go back to. Every block is one of VoxeLibre's own nodes as far as VoxeLibre has it, registered as a copy of its look without its behaviour: nothing falls, decays, flows or can be dug. 144 lettered boards carry each venue's own words.

    siteGRIFT placestreetspotsthere · drawn

    Entities and nodes
    nameis
    grift:residenta resident's body: VoxeLibre's jointed character model, dressed from VoxeLibre's own character parts (skin tone, hair, eyes, top, trousers, shoes, now and then glasses), chosen by the rule San Verano's own city dresses its crowd by: the home district decides the style of clothes, the resident's number everything else. Posed bone by bone by the mod (walking, sitting, a pose for each kind of work). Not saved with the world; right-click or punch shows its card
    grift:tagthe tag over its head, attached to the body: a texture the mod composes from the record's words, in San Verano's pixel lettering
    grift:platea venue's lettered board
    grift:<block>the district's blocks: 123 kinds drawn as VoxeLibre's nodes, 4 it has none of drawn plainly
    grift:filllight-only air above indoor standing spots the lamps do not reach. It draws nothing and stops nothing
    Identity tags

    Every drawn resident carries a tag. Close by, the nearest few carry their name and number in their trade's colour, with the trade beneath (· on shift for staff at work); one followed or pinned resident at a time also carries the record's sentence for the hour and who planned its day. Further off, or in a crowd, the tag shrinks to the number alone, so every figure on screen can still be looked up. Two names are never drawn shoulder to shoulder.

    For a picture taken by the checking camera (unless grift_label = full) the rules tighten: at most two names, each tag kept the same size on screen whatever its distance, and a number that would lie over a name left off that picture. The two-line label at the top becomes a small RECORDED mark with the recording's date; the full details go in a file beside the picture.

    Businesses

    A business is one of GRIFT's places, given a site in the district: a door on its street, a floor, and standing spots marked with what a resident does there (serve, deal, spar, busk, a stool at the bar, a booth). Staff of the trade that works there stand on its staff spots while the record has them on shift; guests take the guest spots their plan sends them to. Its name, sign and lettering are the city's own; its card, from a lectern inside, says how many the record has there and how many are drawn.

    LAST CALL and its stretch of Juniper St are built as San Verano's own 3D city has them: dark brick, a door set back in its bay under a low lit canopy, small amber windows, the neon sign, a counter with stools, booths and lamps, and an avenue with a thin double yellow line, kerbs, slabs, lamps and street trees. The other venues are the district's blocks as planned.

    The game as it runs In game Recorded source

    The voxel district and its residents

    The Luanti window on the development machine, running build 5275cd52 on the city's own clock: nothing was moved to a chosen hour. Eight are frames of takes recorded in the running game, the camera flown by a separate camera mod through the Lua interface below (it pins a resident and fixes its tag; it moves nobody); one is from the mod's checking camera. Each is the game's own picture at 1920 by 1080, without the window's title bar, saved as JPEG and otherwise unedited. The small mark in the corner is the mod's: RECORDED and the day the record was read. Renderer settings are listed under Testing.

    Each still names when it was captured and the city time on its label. Nothing generated, composited or staged is shown here.

    Installation and quickstart

    Check the record today. Run the mod when it is distributed.

    What is public today is the record: the census the mod bundles, GRIFT's answer it was made from, and the mod's own answers from inside the engine. The mod itself is not distributed yet, so the installation below is written down as it is run on the development machine, for the integration to be assessed. Why it is held.

    Check the record works today

    Needs curl, and Node 20 or later for the second step. Nothing is installed.

    1. Check the one hash everything hangs from: GRIFT's own recorded answer.

      curl -fsS https://www.grift.world/docs/gta/world.json | shasum -a 256
      output
      ded227731a198382af5891efd651f18bb147925b45a270a0794168135c2ad720  -

      That is the hash the mod reports for the read it replays (grift.provenance().census.sha256, below).

    2. Read what the mod answered inside Luanti, and compare.

      curl -fsS https://www.grift.world/docs/luanti/examples.json | node -e "const d=JSON.parse(require('fs').readFileSync(0,'utf8')); console.log(d.engine.project, d.engine.string, '·', d.game); console.log(d.examples.provenance.label); console.log(d.examples.provenance.census.sha256)"
      output
      Luanti 5.18.0 · VoxeLibre
      RECORDED · GRIFT, 2026-11-09T19:26:16.918Z · plan day 996806
      ded227731a198382af5891efd651f18bb147925b45a270a0794168135c2ad720
    3. Look up any resident in the resident record above and press Check against GRIFT's answer: the comparison runs in your browser.

    Install and run the mod reference only · not distributed

    As run on the development machine: macOS, Luanti 5.18.0, VoxeLibre 0.92.4. You cannot follow these steps until the mod is offered for download.

    1. Luanti 5.18.0 and the game VoxeLibre are installed. In Luanti's files VoxeLibre's game id is mineclone2.

    2. The mod folder grift is copied into Luanti's mods folder. A copy, not a link: Luanti's mod security does not follow a link out of its folder.

    3. A world of its own is made for it, with these lines in its world.mt. The mod turns the world it is enabled in into San Verano, so it is never enabled in a world that holds anything else.

      worlds/san_verano/world.mt
      world_name = san_verano
      gameid = mineclone2
      enable_damage = false
      creative_mode = true
      load_mod_grift = true
    4. Luanti is opened, VoxeLibre chosen, the world san_verano played. On start the log says what the mod holds:

      debug.txt
      [grift] San Verano: 6168 residents, RECORDED · GRIFT, 2026-11-09T19:26:16.918Z · plan day 996806; read-only, no model calls, nothing written to GRIFT
    5. In the game: K flies and J goes fast (Luanti's own keys). Right-click a resident for its card, right-click a lectern for a venue's. In chat:

      chat
      /grift status
      answer
      RECORDED · GRIFT, 2026-11-09T19:26:16.918Z · plan day 996806
      mode recorded · city time 20:25
      28 of 6168 residents drawn (28 bodies) · 2092 at home, 209 between places
      bodies stood up 28, removed 0
      read-only: no model is asked anything, nothing is written to GRIFT.

    Developer reference

    Settings, the Lua interface, commands and the data

    The interfaces of the working mod, documented from its source. Every output below is the mod's own answer, written down by Luanti 5.18.0 running VoxeLibre as a server with no window, with the mod's clock held at one instant (city time 20:25 of the replayed day) so that a second run gives the same answers. The whole set is in examples.json. Nothing here writes to GRIFT.

    Settingsminetest.conf

    Read once when the mod loads.

    settingdefaultmeaning
    grift_max_visible28how many residents the director fills the district up to, over those it always draws (followed, pinned, already walking)
    grift_radius130nodes from a site's door or its floor within which a player makes that site one the director draws
    grift_walkers1.0how much of each site's flow of arrivals is drawn. Above 1 fills the pavements with more of the residents the record has walking, never with anyone else
    grift_picture_settingstruewhether the mod raises five of the engine's view settings for the session so the whole district is sent and drawn. false leaves them alone
    grift_selftestfalseruns the mod's check of itself in the engine, writes grift-selftest.json into the world's folder and stops the server
    grift_shotsfalsea camera tour for checking the build: it moves the first player from view to view. grift_shots_only picks views
    grift_debug_hourunsetfor checking only: starts the replay at that city hour instead of the hour the real clock gives. The label on screen then says the replay was moved
    grift_labelfullmark replaces the two-line label at the top of the screen with a small RECORDED mark and the recording's date. The checking camera uses it, with the tighter tag rules for its pictures, unless grift_label = full
    grift_mark_scale0.667the size of that mark (two screen pixels a dot on the development machine)

    Lua interfacethe global grift

    For another mod in the same world: put depends = grift in its mod.conf. Everything returns plain tables built from the census and the feed the mod holds. A mod that shows a resident's record should show grift.clock().label with it.

    functionreturns
    grift.clock()known, hour, cityTime, label, mode, nowMs, planDay, shiftMs, provenance. known is false when no current day is held, and then nobody is drawn
    grift.provenance()the read of GRIFT everything is drawn from: mode, label, census = { url, fetchedAt, sha256, bytes }, recordedAt, planDay, residents, feed
    grift.sites()the district's sites in order: key, name, street, door, hub, exit, and, once the director has run, present and shown
    grift.residents_at(venue)a row for each resident drawn at that site right now; with no argument, everyone drawn. Nothing is moved for whoever asks
    grift.resident(id)one resident's row, or nil when it is not drawn right now
    grift.pin(id, on)draws that resident first whenever the record has it at, or walking to, a site the district draws and a player is within grift_radius of that site (and a spot of its role is free). It is never moved
    grift.show_resident(player, id)opens the resident's card for a player
    grift.set_label_visible(name, on)shows or hides the label at the top of that player's screen
    grift.set_label_style(name, style)"full" or "mark", for one player: the two-line label or the small RECORDED mark
    grift.plate_scaleunset, plates are drawn smaller the nearer the nearest player stands; a number fixes their size
    grift.plate(id, mode)which plate a resident carries: "compact" (its number), "full" (name, number, trade) or "expanded" (the record's sentence as well); nil gives it back to the mod, which names the nearest five and never two side by side
    grift.hold_cast(seconds)for up to 90 seconds nobody standing is taken out of the picture, as long as the record still has them at that place
    grift.lettering(id, on)takes a piece of a venue's lettering out of the picture, or puts it back

    A row, from residents_at and resident:

    fieldmeaning
    id · name · tradethe resident, by GRIFT's census
    plate · tagthe two lines over its head: NAME · #id in capitals, accented letters included (BERGSTRÖM), and its trade with · on shift or · own stall when the record says so
    nowthe card's sentence for this hour
    site · state · actthe site's key; standing, walking or waiting; what its spot has it doing (serve, spar, busk …) or walk, wait, stroll
    pos · yaw · bodywhere it is in the world, which way it faces, and whether its entity exists
    slot · whythe plan slot the hour falls in (aft; night from 21:00, or earlier when the stay or walk is to the plan's night place) and that slot's reason in the plan's own words, screened. nil for staff on shift: a shift is not a choice
    remaining · untilthe real seconds, and the city time, the record's walk or stay still has to run
    behind · moving · sitting · speedthe body, as apart from the record: seconds of walking it still owes, whether it is walking, whether it is seated, its pace in nodes a second
    followed · decidedBy · decidedAt · latelyfor the few agents the feed follows: who planned the day, when, and its last nights in the city's words. For everyone else followed is false, decidedBy and decidedAt are nil and lately is empty: who decided was not read

    The mod's own tables are readable too: grift.city (residents, byId, places, jobs, provenance), grift.Schedule.presence(resident, hour), grift.Card (plate, tagLine, now, resident), grift.Clock.format(hour), grift.Places (sites, order, siteKey) and grift.Policy.screen(text). They are the mod's internals, not a versioned API: treat them as read-only.

    Integration examplesidentity · employment · schedule

    What the mod holds, and how fresh it is.

    lua · your mod, in the same world
    -- mod.conf of your mod:  depends = grift
    local c = grift.clock()
    print(c.known, c.cityTime, c.mode)     --> true   20:25   recorded
    print(c.label)                         --> RECORDED · GRIFT, 2026-11-09T19:26:16.918Z · plan day 996806
    print(c.planDay)                       --> 996806
    
    local p = grift.provenance()
    print(p.residents, p.recordedAt)       --> 6168   2026-11-09T19:26:16.918Z
    print(p.census.url)                    --> https://www.grift.world/api/city?view=world
    print(p.census.sha256)                 --> ded227731a198382af5891efd651f18bb147925b45a270a0794168135c2ad720

    Who is drawn at a venue right now. bar is GRIFT's key for LAST CALL.

    lua
    for _, r in ipairs(grift.residents_at("bar")) do
      print(r.id, r.plate, r.tag, r.state)
    end
    --> 13   MARCUS UGARTE · #13   busker   walking
    --> 18   BO STAVRAKAKIS · #18   detective   walking
    --> 1876   TARQUIN FONTAINE · #1876   barback · on shift   standing
    --> 5330   PRIYA QUINTERO · #5330   barback · on shift   standing
    --> 100123   MARLO FENWICK · #100123   busker   standing

    One resident, as drawn. Resident 13 at city time 20:25, on its way from its pitch to the bar its plan chose:

    lua
    local r = grift.resident(13)    -- nil when the record does not have it out somewhere this district draws
    if r then
      print(r.name, r.trade)           --> Marcus Ugarte   busker
      print(r.now)                     --> Walking from work (busker), which this district puts at CENTRAL PARK to LAST CALL, due 20:28.
      print(r.site, r.state, r.act)    --> bar   walking   walk
      print(r.slot, r.why)             --> night   Drink's ten dollars, I'll have one.
      print(r.followed, r.decidedBy)   --> true   GRIFT's planner model
      print(r.decidedAt)               --> 2026-11-09T19:05:47.076Z
    end

    Identity, employment and schedule from the census. This works for every resident, drawn or not:

    lua
    local m = grift.city.byId[13]
    print(m.name, m.kind, m.district)                    --> Marcus Ugarte   native   Finance
    print(m.job.name, m.job.shift[1], m.job.shift[2])    --> busker   12   20
    print(m.aft.choice, m.aft.why)                       --> work   on shift, this one was not a choice
    print(m.night.choice, m.night.spend, m.night.why)    --> bar   10   Drink's ten dollars, I'll have one.
    print(#m.schedule)                                   --> 12
    
    local hour = grift.clock().hour
    local p = grift.Schedule.presence(m, hour)
    print(p.mode, p.place, p.from, p.decision)           --> arriving   bar   work:busker   plan
    print(grift.Clock.format(p.h0), grift.Clock.format(p.h1))   --> 20:14   20:28
    print(grift.Card.plate(m), grift.Card.tagLine(m, p)) --> MARCUS UGARTE · #13   busker
    print(grift.Places.siteKey(p.place, m))              --> bar

    Head counts. The true number present by the record, and how many of them are drawn:

    lua
    for _, s in ipairs(grift.sites()) do
      if s.key == "market" or s.key == "bar" then print(s.name, s.street, s.present, s.shown) end
    end
    --> LAST CALL   Juniper St   207   5
    --> THE NIGHT MARKET   Del Mar St   1168   5

    Keep one resident in view. A pinned resident is drawn first whenever the record has it out; the record still says where.

    lua
    grift.pin(13, true)
    -- later
    grift.pin(13, false)

    Chat command/grift

    commanddoes
    /grift statusthe label, the city's time, how many are drawn, at home and between places
    /grift who <#id or name>a resident's card. Any resident of the census, drawn or not
    /grift sitesevery site with its street, how many are there by the record and how many are drawn
    /grift venue <place>a venue's card: its head count now and, for LAST CALL, the house's own record
    /grift tp <place or #id>moves the player to a site's door, or beside a resident who is drawn. The player, never the resident
    /grift follow <#id> · unfollowpins a resident, as grift.pin
    chat
    /grift who 13
    answer · the card
    A RESIDENT OF SAN VERANO
    
    Marcus Ugarte · #13
    native resident
    Trade: busker
    Home district: Finance
    Crew: k2
    Cash: $9,974 city dollars (a number in GRIFT's simulation)
    
    NOW  ·  city time 20:25
    Walking from work (busker), which this district puts at CENTRAL PARK to LAST CALL, due 20:28.
    (The plan chose where it is going. The route is this server's drawing.)
    
    TODAY'S PLAN (GRIFT's record)
    Afternoon: on shift (hours, not a choice)
        "on shift, this one was not a choice"
    Night: LAST CALL
        "Drink's ten dollars, I'll have one."
        may spend up to $10 (a cap, not a purchase)
    
    WHO DECIDED (GRIFT's trace)
    Planned by: GRIFT's planner model
    (A model made the plan. Its name is not shown here.)
    the last three nights, in the city's own words:
        at work
        bar · $10
        at work
    
    SOURCE
    RECORDED · GRIFT, 2026-11-09T19:26:16.918Z · plan day 996806
    Read: https://www.grift.world/api/city?view=world
    At: 2026-11-09T19:26:17.736Z
    SHA-256 of that answer: ded227731a198382…
    This world reads only. It asks no model anything and writes nothing to GRIFT.

    What it changes in a world

    The mod is a whole place, not an add-on. Enabled in a world, it makes that world San Verano, which is why it is given a world of its own.

    whathow
    the mapflat ground (singlenode map generation) with the district placed as the map is generated. Its blocks cannot be dug
    LAST CALL and Juniper Stdressed over the district's plan in the look of San Verano's own 3D city: the brick front with its door bay, canopy, windows and neon sign; inside a counter with stools, booths and amber lamps; outside the road's lines, kerbs, slabs, street lamps, trees and street furniture. The dressing is versioned: a world made with an older one is dressed again once, as its light is worked out again
    time and weatherthe time of day follows the city's clock; VoxeLibre's weather is kept clear; its clouds are hung above the skyline (height 190) instead of at street level
    mobsremoved as they appear: the only bodies in San Verano are its residents
    playersgiven fly, fast, noclip, teleport and interact, and placed in the district on joining
    five view settingsblock_send_optimize_distance, max_block_send_distance, server_side_occlusion_culling, enable_raytraced_culling, client_mapblock_limit are raised when the mod loads and put back when the world closes. grift_picture_settings = false opts out
    lightfive seconds after the first player joins, the district's light is worked out again over 12 map chunks, then light-only air is placed above indoor standing spots the lamps do not reach

    Data filesin the mod's folder

    fileholds
    data/census.jsonthe recorded census, whole: grift.city.census 0.1, 6,168 residents. The same rows, roster and head as the public census on this site. Rows are positional and index a dictionary: [id, name, kind, district, job, crew, cash, model, aft, night, schedule]; a segment is [h0, h1, kind, place, from, role, slot, decision], in city hours from 6 to 30
    data/feed.jsongrift.agents.feed 0.1, cut down to what the mod reads: 12 followed agents and LAST CALL's trading day
    data/district.jsonthe district: sites, standing spots with what a resident does on each, the routes between sites, the lettered boards
    schems/district.mtsthe district's blocks, as a Luanti schematic
    data/nodes.json · data/font.jsonthe block kinds and the trade colours; the plate lettering as dots
    data/reference.jsonsix scenes worked out by the reference director the Lua one was ported from, which the self-test compares it with
    textures/lettering and plain 16-pixel block textures, made by the mod's own exporter, and 128 tunic skins the current build no longer uses. The textures of LAST CALL's and Juniper St's dressing are drawn in Lua when the mod loads. Residents wear VoxeLibre's own character parts (mcl_skins, CC BY-SA), which the game serves: no game's art is in the mod

    Sizes and SHA-256 of the mod's files as documented here: mod.json.

    JavaScriptbrowser · Node 20+

    There is no JavaScript in the game. What exists in JavaScript is this page's reader, /js/luanti/record.js: the mod's plate, its line, its sentences and its card, written again and held to the mod's answers inside Luanti (every resident at nine hours of the day: 55,512 cards, no difference). It shares its clock, decoder and schedule with /js/gta/record.js, the reader of the same census for another engine.

    js · in a page on this site, or in Node with the files downloaded
    import { decodeResident, presence, now, plate, tagLine, card, siteKey } from '/js/luanti/record.js';
    
    const get = (path) => fetch(path).then((r) => r.json());
    const [head, { dict }, sites, followed] = await Promise.all([
      get('/docs/gta/census/head.json'), get('/docs/gta/census/dict.json'), get('/docs/luanti/sites.json'), get('/docs/luanti/followed.json')]);
    const places = Object.fromEntries(dict.places.map((p) => [p.key, p]));
    
    // rows are in id order, 500 to a page; natives 0-5999 fill pages 0-11
    const { residents } = await get('/docs/gta/census/0.json');
    const marcus = decodeResident(dict, residents.find((row) => row[0] === 13));
    
    const hour = 20.4167;                                           // 20:25 on the city's clock
    console.log(plate(marcus), '|', tagLine(marcus, presence(marcus, hour)));   // MARCUS UGARTE · #13 | busker
    console.log(now(places, sites, marcus, hour)[0]);               // Walking from work (busker), which this district puts at CENTRAL PARK to LAST CALL, due 20:28.
    console.log(siteKey(sites, presence(marcus, hour).place, marcus));          // bar
    console.log(card(head, places, sites, followed, marcus, hour).join('\n'));  // the card above, line for line

    Testing

    Engine · no window The mod checks itself inside the real engine. With grift_selftest = true a Luanti server generates the district in a throwaway world, compares the Lua director with the reference one at six instants, stands the residents up, watches them move, and writes what it found. The last run, as the engine wrote it (selftest.json):

    checkresult
    Loading the self-test…

    bash · in the private work tree
    sh luanti/tools/selftest.sh                                   # the self-test above, in a server with no window
    HOUR=real DEBUG=false sh luanti/tools/render.sh name out/ luanti/tools/picture.conf   # the screenshots: the real client, the city's own clock

    The speed check is not settled. A body's position as the server keeps it sometimes steps further in one tick than its velocity allows, on a resident far from the player; the check then fails. The run above was taken at a city hour when nobody walked, so it says nothing either way. In recordings of the client measured frame by frame, walkers advanced evenly, with no hop.

    Renderer settings of the screenshots (luanti/tools/picture.conf, a client configuration; the mod changes none of them). Luanti 5.18.0 on this Mac runs only its OpenGL 2.1 driver: asking for opengl3 fails and falls back. Chosen from trials in the running client:

    settingwhy
    tone_mapping = true · enable_bloom = truecontrast, and a glow on the neon and the lamps, at no measurable cost
    antialiasing = ssaa · fsaa = 2the only anti-aliasing that has any effect here; multisampling is ignored with post-processing
    mip_map = true · anisotropic_filter = truedistant pavement and brick calm, near textures still crisp. Trilinear filtering was tried and smears them
    enable_dynamic_shadows = falseshadows work, at half the frame rate, and show nothing at dusk or by night
    enable_volumetric_lighting = falseit washes out the street at sunset

    Troubleshooting

    What running it has taught so far, on the one machine it has run on.

    you seecausedo
    VoxeLibre stops with "database is locked"the world is still held by a game that was closed a moment agoone game per world at a time: wait until the first has gone
    white streets from a roof, white haze at street levelVoxeLibre hangs its clouds at a height that is head height on San Verano's streetsnothing: the mod lifts them. If another mod sets clouds, it wins
    ground missing far off, seen from the airLuanti's defaults stop sending ground-level blocks a few blocks outleave grift_picture_settings on
    rooms black for the first secondsa map chunk is lit as it is generated, before its neighbours existwait: the mod works the light out again five seconds after the first join
    a card says a resident is at a place and it is still walking therethe body walks at a walking pace, and a city hour is 75 real secondsnothing: the card adds a line saying its body is behind the record, and a row's behind says by how much
    a label says 207 here and you count 5everyone is counted, a few are drawnraise grift_max_visible within what the machine holds
    nobody is drawn at a siteno player is within grift_radius of its door or floor, or the record has nobody there at this hour: between about 03:30 and 08:00 almost everyone is at home/grift sites says how many the record has at each
    the title bar says OpenGL 2.1 and five context warnings are in the logmacOS gives Luanti no OpenGL 3 context of the kind it asks fornothing: it runs on the OpenGL 2.1 driver, with shaders, bloom and tone mapping
    the next launch hangs on macOSafter a game is killed, macOS asks whether to reopen its windowschoose not to reopen; close a test game from inside (core.request_shutdown)

    Evidence

    Three kinds of evidence, kept apart

    A claim on this page is backed by one of three things, and they are not worth the same. Each row says which it is.

    In game

    The game with its window open. What a player sees: the real Luanti client on the development machine, captured. Genuine, and narrow: one machine, one player.

    Engine · no window

    The real engine as a server. Luanti 5.18.0 running VoxeLibre and the mod with no client. It proves what the mod computes and what entities exist. It cannot show how anything looks.

    Record

    Recorded-source consistency. Arithmetic on the recording: that the census the mod bundles, and this page, say what GRIFT's recorded answer says. No game is involved. Anyone can repeat it.

    claimevidenceresult
    In game
    Residents stand in the district with their plates, at the venues the record has them at
    the nine screenshots: the game window on build 5275cd52, on the city's own clock, 2026-11-11 between 16:23 and 22:56 UTCshown
    Engine · no window
    The mod's director draws what the reference director draws
    the self-test: the same residents, sites and states at six instants of the recorded day; everyone standing on the same spot, everyone walking within 2.5 nodes6 of 6 instants
    Engine · no window
    The generated world is the district's model, in VoxeLibre's blocks
    the self-test: 4,000 sampled positions of the generated map against the model; 123 block kinds drawn as VoxeLibre's nodes, 4 drawn plainly4000 of 4000
    Engine · no window
    Residents are entities that carry their plates and move like bodies
    the self-test: a body and a plate for each resident drawn; some moved while the engine ran, none faster than a brisk walk, none turning faster than a body turnspassed
    Engine · no window
    No resident is walked through a block
    the self-test walks every way across every floor and every line between two places, the body's width and a walker's lane included, against the blocks that are therepassed; two fighters step up into the ring through its edge
    Engine · no window
    The outputs printed on this page are the mod's
    every documented call asked of the mod inside the engine, the answers written down by Luanti: examples.jsonas printed
    Record
    The census the mod bundles is the public census
    its rows, roster and head against the 13 public pages; only the dictionary's model names differ, which the public copy replaces by the word "declared"identical
    Record
    Every resident is what GRIFT's own answer says of the same number
    all 6,168 against GRIFT's recorded answer, field by field: name, trade, district, both choices, both reasons. Run it for one resident in your browser above6168 of 6168
    Record
    This page's lookups are the mod's
    this page's JavaScript against the cards the mod wrote inside Luanti, every resident at nine hours: the card, the plate, the line under it, the site55,512 compared, 0 different

    Limits of this evidence

    • One machine. macOS, Luanti 5.18.0 on its OpenGL 2.1 renderer, VoxeLibre 0.92.4. Linux, Windows, other versions of VoxeLibre and other games have not been tried.
    • One player, or none. It has run in single-player and as a server with no client. A server with several players has not been run.
    • At most 28 residents drawn by default. The rest are counted on the label and the cards.
    • Bodies run behind the record. They walk at a walking pace, and the city's clock does not always leave time for it: on a long walk a body can arrive tens of seconds after the record's hour.
    • One street and one venue are rebuilt. LAST CALL and its stretch of Juniper St have the city's own look and seats to sit on. The other venues are the plan's blocks, and their guests stand.
    • One check is open. The self-test's speed check sometimes fails on a resident far from the player (see Testing).
    • Nothing here is live. Every still and every output is the recording of 2026-11-09, replayed.
    • The recording is not signed. The checks show it is intact and is the one the census names. They cannot show that GRIFT gave that answer at that time.
    • Who decided is known for 12 residents in this recording: the agents the feed followed. For the other 6,156 the card says it was not read.
    • The screenshots are cameras' views, a camera mod's and the checking camera's, on the city's own clock. They show what the game draws at those moments, not a player's session.
    • No props. A busker strums a guitar that is not drawn; a bartender wipes a counter with no cloth.

    Status

    Implemented, recorded playback, and not built

    Three lists, kept apart. Only the first is claimed, and each line in it says what kind of evidence it rests on. The second says what replaying a recording does and does not mean. Nothing in the third exists.

    Implemented

    • In game The district in blocks, with its venues' lettering: LAST CALL, THE NIGHT MARKET, IRON CORNER, CENTRAL PARK, THE CROWN and ten more places.
    • In game Residents as entities with their tags, name and number in the trade's colour, the trade beneath; the number alone further off.
    • In game Each resident dressed as its own, from VoxeLibre's character parts by San Verano's wardrobe rule, the same every time.
    • In game LAST CALL and Juniper St in the city's own look, and every venue with its name, lettering, staff spots and card.
    • Engine · no window The director: who is at each site by the census, who is drawn, on which spot, held to the reference at six instants.
    • Engine · no window Movement along the record's walks: setting out on GRIFT's time, then the pavement, the door and the spot at a walking pace, round the furniture, to a seat where there is one. In game walkers move evenly, with strides matched to the ground covered.
    • Engine · no window The card and the venue card, the /grift command and the Lua interface, with the outputs on this page.
    • In game The city's clock as the sky: day, dusk and night by San Verano's hour.
    • Record The whole-city census the mod bundles: 6,168 residents, each GRIFT's own answer field for field.

    Recorded playback · what it means

    • One day, replayed. The plans were written by GRIFT on 2026-11-09. The game replays that day every 30 minutes; it does not show today's.
    • No decision is made in the game. No model is asked anything while it runs. A reason on a card is the plan's own, written before the recording.
    • Places and hours are GRIFT's; routes, spots and bodies are this world's. The card says which is which.
    • A count is the record's. "207 residents here" is the census at that hour, of whom a few are drawn.
    • Nothing a player does reaches a resident, the record or GRIFT.

    Developer kit

    What you can download, and what is held

    Public record available

    The mod's answers from inside Luanti, its self-test, the district's sites, who decided for the followed agents, and the sizes and hashes of the mod's files. The census and GRIFT's recorded answer are the ones already public on this site. Data only: no Lua, no schematic, no texture.

    The Luanti mod not distributed yet

    The mod is a development build. It takes over the world it is enabled in, so it must not be offered before it refuses any world but its own; and it has no licence yet. There is no public repository. Nothing on this page lets you download it. The interfaces are documented so the integration can be assessed without the source.

    filesizeSHA-256
    Loading the manifest…

    A RECORDED file never becomes live: each carries the date it was read.