Project I.G.I. : I'm Going In
Portage natif de Project I.G.I. : I'm Going In pour macOS.
openigi est un portage natif de Project I.G.I. : I'm Going In pour macOS, distribué en binaire dans ses releases.
Architecture
Mac OS X - macOS
Apple Silicon
64-bit
Original game
Project I.G.I. : I'm Going In Windows
Download and links
- Download Project I.G.I. : I'm Going In
- Source code 175 GitHub stars
- License : GPL-3.0
Version history
0.6.9-beta.5
Full changelog
Fixes
- igi2: The player runs the human's own tick, so a shot's hold on its visibility wears off
- igi2: The HUD's eye turns red once a squad has spotted the player, not while the meter runs high
- igi2: Co-op players move as their own game moved them -- each command run once, begun where its client looked, and partners animated
- igi2: A body behind a bush is seen through its leaves on the original's look
Downloads
The easiest way to play is the OpenIGI Launcher (openigi.com or its releases), which installs this build for you once its update channel is set to Beta. To run the game yourself, each build comes in two flavours: self-contained runs on any machine, and .NET is a fraction of the size but needs the .NET 10 runtime installed.
| Self-contained | Needs .NET 10 | |
|---|---|---|
| Windows | openigi-game-0.6.9-beta.5-win-x64.exe | openigi-game-0.6.9-beta.5-win-x64-dotnet.exe |
| Linux | openigi-game-0.6.9-beta.5-linux-x64 | openigi-game-0.6.9-beta.5-linux-x64-dotnet |
| macOS (Apple silicon) | openigi-game-0.6.9-beta.5-osx-arm64.tar.gz | openigi-game-0.6.9-beta.5-osx-arm64-dotnet.tar.gz |
Windows and Linux builds are a single executable (on Linux, chmod +x it first). macOS builds are an app in a tarball.
On macOS and Linux, the launcher installs with one command: curl -fsSL https://openigi.com/install.sh | bash.
The macOS builds are not notarized, so macOS reports an app downloaded with a browser as "damaged"; clear that with xattr -dr com.apple.quarantine "/Applications/OpenIGI Launcher.app" (or the app's path).
OpenIGI needs your own copy of Project I.G.I.; it ships none of the game's data. Verify a download with sha256sum -c SHA256SUMS.
Dedicated server: openigi-server-0.6.9-beta.5-linux-x64.tar.gz (sudo ./install.sh) or openigi-server-0.6.9-beta.5-win-x64.zip (.\install.ps1); it plays your own copy of the game too.
On ARM hosts: openigi-server-0.6.9-beta.5-linux-arm64.tar.gz or openigi-server-0.6.9-beta.5-win-arm64.zip, installed the same way.
0.6.9-beta.4
Full changelog
New
- web: The game opens and plays with no network once it has been played: a service worker keeps the page and its runtime, and lets an earlier release's runtime go
- mp: The kill feed shows the weapon's silhouette and how a kill struck, lights the player's own rows, and announces its kills
Fixes
- motion: Moving things are drawn between ticks with the camera that looks at them, and stamp their own motion
- hud: World markers are placed through the camera the frame was drawn from
- web: After Escape the view holds still until a click takes the mouse back, that click fires nothing, and Click to resume says so; a browser gives the pointer back to no timer
- vfs: A folder listed for case folding is listed again when it has been written since, so a file that arrives later is found
- coop: A player alone is not left down for ever, and I.G.I. 2's players wear the look they chose
- coop: A LAN game plays in the chosen look, and co-op's fall and looks are tested on two I.G.I. 2 games
- coop: I.G.I. 2 partners hold their guns, spare each other without friendly fire, and a fallen one beeps once
- mp: The kill feed sample takes its weapons from the title's armoury, so the host names no game's content, and hud_killfeed is in the settings baseline
Downloads
The easiest way to play is the OpenIGI Launcher (openigi.com or its releases), which installs this build for you once its update channel is set to Beta. To run the game yourself, each build comes in two flavours: self-contained runs on any machine, and .NET is a fraction of the size but needs the .NET 10 runtime installed.
| Self-contained | Needs .NET 10 | |
|---|---|---|
| Windows | openigi-game-0.6.9-beta.4-win-x64.exe | openigi-game-0.6.9-beta.4-win-x64-dotnet.exe |
| Linux | openigi-game-0.6.9-beta.4-linux-x64 | openigi-game-0.6.9-beta.4-linux-x64-dotnet |
| macOS (Apple silicon) | openigi-game-0.6.9-beta.4-osx-arm64.tar.gz | openigi-game-0.6.9-beta.4-osx-arm64-dotnet.tar.gz |
Windows and Linux builds are a single executable (on Linux, chmod +x it first). macOS builds are an app in a tarball.
On macOS and Linux, the launcher installs with one command: curl -fsSL https://openigi.com/install.sh | bash.
The macOS builds are not notarized, so macOS reports an app downloaded with a browser as "damaged"; clear that with xattr -dr com.apple.quarantine "/Applications/OpenIGI Launcher.app" (or the app's path).
OpenIGI needs your own copy of Project I.G.I.; it ships none of the game's data. Verify a download with sha256sum -c SHA256SUMS.
Dedicated server: openigi-server-0.6.9-beta.4-linux-x64.tar.gz (sudo ./install.sh) or openigi-server-0.6.9-beta.4-win-x64.zip (.\install.ps1); it plays your own copy of the game too.
On ARM hosts: openigi-server-0.6.9-beta.4-linux-arm64.tar.gz or openigi-server-0.6.9-beta.4-win-arm64.zip, installed the same way.
0.6.9-beta.3
Full changelog
New
- coop: I.G.I. 2 played together, as I.G.I. is
- mp: I.G.I. 2 is hosted in co-op alone for now
- web: I.G.I. 2 plays in the browser, downloaded in pieces like I.G.I. 1
Fixes
- menu: The level behind the menu is the campaign's first mission, not mission 1, which in I.G.I. 2 is a multiplayer map
- config: A configuration with no profiles plays as the original's default operative, Joe, instead of No profile
- webgpu: I.G.I. 2's water compiles in a browser: its sun vector was emitted as a WGSL const of override constants, and every frame with water in view was dropped
- cutscene: I.G.I. 2's cutscenes let the mouse go as I.G.I.'s do, so a browser lets Escape be held to skip
Performance
- igi2: The 24-bit truncated multiply finds its result without a fused multiply-add when the double product is off the grid, bit for bit the same; a browser's software fma was a tenth of its frame
- igi2: A soldier is posed when it is drawn or a line comes near it, as the original's cube tree reaches it, not every soldier for every line
- web: No interpreter in the hot paths of a browser frame
Downloads
The easiest way to play is the OpenIGI Launcher (openigi.com or its releases), which installs this build for you once its update channel is set to Beta. To run the game yourself, each build comes in two flavours: self-contained runs on any machine, and .NET is a fraction of the size but needs the .NET 10 runtime installed.
| Self-contained | Needs .NET 10 | |
|---|---|---|
| Windows | openigi-game-0.6.9-beta.3-win-x64.exe | openigi-game-0.6.9-beta.3-win-x64-dotnet.exe |
| Linux | openigi-game-0.6.9-beta.3-linux-x64 | openigi-game-0.6.9-beta.3-linux-x64-dotnet |
| macOS (Apple silicon) | openigi-game-0.6.9-beta.3-osx-arm64.tar.gz | openigi-game-0.6.9-beta.3-osx-arm64-dotnet.tar.gz |
Windows and Linux builds are a single executable (on Linux, chmod +x it first). macOS builds are an app in a tarball.
On macOS and Linux, the launcher installs with one command: curl -fsSL https://openigi.com/install.sh | bash.
The macOS builds are not notarized, so macOS reports an app downloaded with a browser as "damaged"; clear that with xattr -dr com.apple.quarantine "/Applications/OpenIGI Launcher.app" (or the app's path).
OpenIGI needs your own copy of Project I.G.I.; it ships none of the game's data. Verify a download with sha256sum -c SHA256SUMS.
Dedicated server: openigi-server-0.6.9-beta.3-linux-x64.tar.gz (sudo ./install.sh) or openigi-server-0.6.9-beta.3-win-x64.zip (.\install.ps1); it plays your own copy of the game too.
On ARM hosts: openigi-server-0.6.9-beta.3-linux-arm64.tar.gz or openigi-server-0.6.9-beta.3-win-arm64.zip, installed the same way.
0.6.9-beta.2
Full changelog
New
- hud: Allies' names drawn spare: the name with a soft shadow over a small accent marker, no plate
- hud: The revive HUD redrawn spare, as one shared part with an offscreen shot
- hud: A fallen teammate is marked wherever they are: through walls, with how far, pinned to the screen's edge with an arrow when out of view
- hud: Pings as map pins that land with a ripple; allies' tags show a thin health bar while they are hurt
- hud: A teammate going down is told: a short sound and 'Anya is down · 84 m' at the top of the screen
- hud: LOW AMMO, RELOAD or NO AMMO under the crosshair as the weapon runs low (r_ammo_cue)
- hud: The crosshair to your taste: colour, size, thickness, gap, opacity, centre dot, outline, and whether it opens with the spread
- ui: Colour blind mode (r_colorblind): the paired colours drawn apart for deuteranopia, protanopia or tritanopia
- controls: Toggle crouch (in_crouch_toggle), a Movement row in Controls
- hud: The match's card at its end sums up your own match: place, kills, deaths, K/D, and MVP for the one on top
- mp: Spawn protection in deathmatch: two seconds unhurt after a respawn, ended by firing, shown to everyone
Fixes
- render: The glass shaders rebuilt from their sources (stained panes keep their dirt off)
- menus, hud: Saves only from a mission; the scoreboard names the map and shows your avatar; the retail bar's blast warning in solid red
- hud: The original health bar's bars a planted bomb would take flash themselves
Changes
- hud: Allies' name tags drawn by one shared part (AllyTag), with an offscreen shot of them
Downloads
The easiest way to play is the OpenIGI Launcher (openigi.com or its releases), which installs this build for you once its update channel is set to Beta. To run the game yourself, each build comes in two flavours: self-contained runs on any machine, and .NET is a fraction of the size but needs the .NET 10 runtime installed.
| Self-contained | Needs .NET 10 | |
|---|---|---|
| Windows | openigi-game-0.6.9-beta.2-win-x64.exe | openigi-game-0.6.9-beta.2-win-x64-dotnet.exe |
| Linux | openigi-game-0.6.9-beta.2-linux-x64 | openigi-game-0.6.9-beta.2-linux-x64-dotnet |
| macOS (Apple silicon) | openigi-game-0.6.9-beta.2-osx-arm64.tar.gz | openigi-game-0.6.9-beta.2-osx-arm64-dotnet.tar.gz |
Windows and Linux builds are a single executable (on Linux, chmod +x it first). macOS builds are an app in a tarball.
On macOS and Linux, the launcher installs with one command: curl -fsSL https://openigi.com/install.sh | bash.
The macOS builds are not notarized, so macOS reports an app downloaded with a browser as "damaged"; clear that with xattr -dr com.apple.quarantine "/Applications/OpenIGI Launcher.app" (or the app's path).
OpenIGI needs your own copy of Project I.G.I.; it ships none of the game's data. Verify a download with sha256sum -c SHA256SUMS.
Dedicated server: openigi-server-0.6.9-beta.2-linux-x64.tar.gz (sudo ./install.sh) or openigi-server-0.6.9-beta.2-win-x64.zip (.\install.ps1); it plays your own copy of the game too.
On ARM hosts: openigi-server-0.6.9-beta.2-linux-arm64.tar.gz or openigi-server-0.6.9-beta.2-win-arm64.zip, installed the same way.
0.6.9-beta.1
Full changelog
New
- menu: Every page follows the design -- text at the design's own sizes, multiplayer's header, list and side panel as drawn, the quality preset as a bar, bindings named and grouped with a search, the profile's saves along its foot -- and a profile can be renamed, its saves going with it
- editor: Mission logic as rules -- a Rules panel lists each piece of logic as a sentence: when something holds, if some other things do, then these steps in order (make a task's condition hold, wait, call a script function, if and otherwise); every line is picked from what the mission's own objects say of themselves and what its tasks can be made to do, said in the title's words (a terminal is hacked, show the message, complete objective 1), or typed as the game's own expression; a rule is the action layer's chain read as a list, so it shows in the graph too and compiles to the tasks a retail level holds; a rule can be named, switched off, moved and given conditions
- editor: A level's own logic in the Rules panel -- every condition of the level's tasks that the title has words for is listed as what it does and what it waits for (switch the camera on, when not: timer 95 is running or it has run over 120 s), read out of the level without changing it; changing what one waits for writes that one parameter; conditions are said part by part across || and &&, on one line, ticks against GAME_FREQUENCY in seconds, and a message is named by what it says
- editor: A mission played from the editor shows its rules over the game -- each rule waiting, run and how many seconds into play, or switched off, read from the latch each rule is compiled to as the game exports it; ed_logic_watch turns it off
- editor: A Map panel shows the mission from straight above -- the ground cast down pixel by pixel (rows in parallel: the terrain cast keeps nothing, 2.5 s for mission 1 where the serial cast with roofs took 22), every placed model as its outline from above, people, pickups, doors and terminals as marks and areas as the boxes the game turns them to; it opens on where the mission is played, zooms about the pointer, pans with the right or middle button, selects with the outliner and viewport, moves the selection by dragging (an object keeps its height over what it stands on, one undo step), and double-click looks at an object in the viewport; mp_mapshot shares the same picture code. A frame the editor fails to draw is dropped rather than flushed, so an editor fault no longer takes the game with it.
- editor: Guards on the map -- every guard shows which way it faces (its Gamma, the body's +Y as 0x45F890 turns it), and the selected ones (every one with Guards on) how far and wide they see, from their own script's orders over the game's default cone, and the patrol they walk along the AI graph's routes; the patrol's geometry is one helper the viewport's patrol tool now draws from too, and each guard's orders are read off its script and kept as undoable edits written back as a script when the mission is saved
- editor: A guard's behaviour in the Inspector -- under a soldier's parameters, its patrol (Edit Patrol starts the patrol tool), how far and wide it sees, the alarm it runs to and whether it fights first, the patrol it walks once the alarm sounds, the gun it mans and whether it can be hurt, each read off its own script; a change is written into that script only where the order is said (AiGuardScriptEdit, shared engine code): the call replaced, put in after the default handler, or taken out, the rest of the script kept as it was, and read back before it is accepted. Of Project I.G.I.'s 868 guard scripts 842 take such changes; the other 26 are refused with a word rather than half changed.
- editor: What an object is wired to, on the map -- a selected object draws a line in from everything its conditions read and out to everything whose conditions read it, as the mission graph wires them, and an alarm panel to every guard its script sends there (so an alarm shows what sets it off, the guards who answer it, and the sirens, sounds and messages it drives); security cameras draw the arc their head sweeps and the cone where it rests, from the camera's own parameters as 0x4420D0 builds its lens
- editor: Wire objects on the map by dragging -- Ctrl-drag from one object to another offers what the second can be made to do in the title's words (open the door, show the message, sound the alarm) and then which state of the first starts it (when the switch is pressed), and makes that a rule in the Rules panel; a guard dragged to an alarm panel answers it, to a mounted gun mans it, as orders in its own script; editor link #a #b offers the same from the console
- editor: Reinforcements -- Make Reinforcement (Tools) turns the selected guards into ones the game sends in when a rule says Send in the guards: each in a GuardGenerator in its place, holding the soldier with only his guns and his mind as all 82 shipped generators do, his patrol paths moved into a container beside it as level 14 keeps its reinforcements', the type declared where the level lacks it; one undo step; reinforcements show violet on the map; a condition reading a soldier a generator holds is flagged, for he is not there to be read until he is sent in
- editor: Vehicles and gunners on the map -- the routes the game's AI drives each car along (a CarAI's PatrolPath on its AI graph, walked as a soldier's patrol is, by one shared helper), every spline (a train's rail, a road) through its waypoints, and the arc mounted guns' holders and armed vehicles watch, their Viewcone Gamma the yaw either side as gunholder.c turns it, 360 all round; shown for the selected ones, or all with Guards on
- editor: A cutscene sequencer -- a Sequencer panel lays a scene's camera shots (its EditCameras, depth first as the game flattens them, each its duration times the scene's time scale) along its clock, and under them everything the mission cues off that clock (a message, an animation, a sound whose condition waits for CutScene_N.nTick), messages named by what they say; scrub or play it (Space) and the viewport looks through the scene's camera on the engine's own path, a shot that watches a target turned to it; drag a shot's end to lengthen it, a cue to move it (tenths of a second, whole seconds with Shift), written back as the condition wrote it; Add Shot from View puts the viewport's camera in after the shot at the playhead; a shot that rides a vehicle says so and that the preview shows it where the vehicle starts, Play in Game shows it moving; editor scene #id [seconds] opens one from the console
- editor: New cutscenes and ready-made camera moves -- New Cutscene makes a scene of the mission's own (its letterbox, fades and time scale those of the level's first scene, held until a rule plays it, kept in a "Cutscenes made in the editor" container) and opens it with a first shot from the viewport; Add Move lays an orbit, push in, fly-over, crane up or pan round the selected object as shots turned to it the way the game turns a camera to a target, from the side the viewport stands on, one undo step; a new shot sets the hour under the levels' own name ("Time of day (-1 means use default)"); editor scene new, editor move #id and editor seek drive them from the console
- editor: The cutscene's camera path in the viewport -- while the Sequencer is in front, the viewport draws the open scene's flight on the engine's own curve, each shot numbered with a tick the way it looks and the selected one marked, and the camera at the playhead in red; the sequencer moves the view through the viewport's own placing, so a glide left from framing something no longer carries the view off once Look Through stops; an orbit is laid an eighth of a turn a shot so it runs round; editor seek outside stands the view back to show the whole path
- editor: A shot's menu in the sequencer -- right-click a shot to set it to the viewport's camera, glide into the next shot or cut to it, watch an object (Target task ID) or ride one (Link task ID) chosen by name, stop either, or delete it; each one undoable step
- editor: A rule that plays a cutscene plays it once -- a title's action can say what ends it of itself (TaskAction.Until), and Project I.G.I.'s "Play the cutscene" ends on the scene's isFinished, as every retail scene that waits on something runs on "(its start) && !CutScene_N.isFinished" (38 of 45; the rest run on 1 or nothing); the rules compiler writes a drive of such a condition the same way, so a start that stays true no longer holds the scene on its last frame
- editor: Prefabs -- Tools > Save Selection as Prefab keeps the selection with everything under it and each guard's mind (his orders as they will be saved) in a library a game (editor/prefabs/), shelved by what it holds; Place Prefab puts one where the view looks, in this mission or another, as new tasks with free ids whose conditions and references still find each other, every position moved with it, in a container beside the mission's own of the kind, one undo step; a placed guard's mind is his until the mission is saved and written then only if he is still in it; editor prefab save|place from the console
- editor: Autosave and recovery -- while a mission has changes not saved, its objects are copied aside every ed_autosave_minutes (3; 0 never) when they changed since the last copy, the last five a mission, kept out of the project so the game never plays them; saving throws them away; a mission opened with a copy newer than its save offers to recover it (saved into the project and the mission reloaded), discard it, or leave it for later
- editor: Help from the game's own code -- a generator gathers what each task class says about itself and its script parameters (its documentation, under the names the levels declare) into a table an assembly (GeneratedTaskDocs), which both titles give the vocabulary (ScriptVocabulary.HelpOf); the Inspector shows the selected type's line under its header and each parameter's as its tooltip, with what making it hold does where the title has words for it; the property grid takes a wrapped note row
- editor: Patrol Round Selection -- a selected guard's patrol laid as a ring of eight waypoints round the other thing selected (far enough out to walk round it) or round where he stands, each on the AI graph's node there or a new one as a click there makes, walked in turn and round again, one undo step, the patrol tool left on to shape it; editor select also adds to the selection from the console
- editor: Getting Started, a guided first mission -- a panel takes a new mission through a guard, his patrol, an objective, the mission ending when it is met, and a play, each step ticked as soon as the mission shows it done however it was done (judged from the document, MissionGuide) and clicking it opens or runs what does it; it opens itself on a new blank mission and from Window > Getting Started; the Tools menu now holds the Patrol Tool, Patrol Round Selection and the prefab actions
- host: Cutscenes played on the level itself for the editor -- IEditorHost.CutscenePreview plays a scene by the game's own tick while the editor holds everything else: its vehicles drive, its soldiers move, its sounds play and the frame is drawn through its own camera (lens, filter, letterbox); real time, or at any moment: a moment ahead is played on to, one behind by loading the level afresh and playing the scene again up to it, so every moment is the one play reaches (a copy of the level would leave behind what a save does not hold: a vehicle's springs and skids, a car's route); a scene the level's story starts of itself (the intro and those that follow it) is reached as play reaches it, any other is made to play from its start, the containers it stands in let in (ConditionalContainerTask.IsForcedOpen, CutsceneRuntime.Previewed); the level is loaded afresh when the preview ends
- editor: Cutscenes play live in the sequencer -- with Live on (the default where the game can), Play runs the scene on the level itself in real time, its vehicles, soldiers and sounds with it, the viewport drawn through its own camera with its letterbox; scrubbing forward runs the level on to the playhead, and going back plays the level again up to it (a drag behind shows the shots' path until let go), so every moment shown is the game's own; a scene its story does not start from the level's start is made to play, and says so; the level is made to match the mission first (saved and loaded afresh when it has changes, or saves, not yet in it), an edit during a live scene ends it as Play would (saved, loaded afresh with the change), and switching scene or Live off loads the level afresh; Live off keeps the shots' path, which shows changes before they are saved; editor play from the console
- editor: A scene's animations on the sequencer's timeline -- every AnimTask a scene runs (its own children, which it runs as it runs, and any whose Run reads it) is a clip on a row of its own, from its cue on the scene's clock or the scene's start for as long as its keys run, named by what it moves (level 1's intro: the train 1501 for 47.5 s, the helicopter 1502 for 65.3 s); clicking one selects it for the Inspector's key editor, and one started by a cue is dragged along the clock by it; how the scene is shown is said at the ruler's end
- editor: Camera moves keep clear of the ground -- a move's shot laid under the ground or through a roof stands 1.5 m above the surface under it (found from well above, objects and terrain alike) and is turned to its subject again
- editor: Make Intro from Objectives -- Tools makes a scene that pushes in on each thing the mission's objectives are about (each task an objective's complete expression reads, in the objectives' order, once each), gliding from one to the next and kept clear of the ground, played from the mission's start as retail intros are (Initial run, Run "!CutScene_N.isFinished"); one undo step; editor live on|off from the console
- editor: Run Fence to Here -- a selected Fence panel is carried on toward where the view looks: copies of it (its model, its electric expression) end to end a panel's length apart, it and they turned so the long side follows the line (Gamma as the map draws headings), each as high over the ground as it stands, one undo step. Fixed on the way: a heading named Gamma (a Fence's Angle) was not read as the task's orientation, so fences could not be turned in the editor at all; editor select first and editor fencerun from the console
- editor: Guard This Building -- with a building selected, Tools adds a guard at its side and lays his patrol as a ring round it (Add Guard at a point, then Patrol Round Selection), the patrol tool left on to shape it
- editor: The Map panel draws the level as the multiplayer layout page does -- the textured ground and every model from straight above, cut at a storey (Roofs, Ground, Floor 1-4: faces higher over the ground under them than the cut are gone), the plan's walls over it (thin under the cut, thick black where it passes through), the floor under the pointer in a status line, marks on other storeys faint and picked last, moves set onto the storey shown, a measure tool ([ ] storeys, T walls, M measure). One OverheadScene (ground passes, model faces, collision, each face's ground) built by the host for the editor and mp_mapshot alike; drawn on the processor in bands off the frame, the whole level once a storey and the view as finely as shown. editor map floor / zoom from the console
- editor: Play-test controls -- while a mission is played from the editor, F6 holds the level still and F7 steps it a tick (the level's pause, ticks let through one by one), F8/Shift+F8 run it at 0.25x to 4x (the clock's time adjust the weapon wheel slows it by), F2 god (the infinite-health cheat), F3 unseen (new g_cheat_unseen: a guard's sight sweep and a camera's lens leave the player out; hearing untouched), F4 stands the player where the editor's camera was. The cheats' gate is opened for the play-test and everything put back when it ends. The banner shows the keys, those in force lit; editor playtest from the console, run while playing (IEditorSession.WhilePlaying)
- editor: The guards' minds over a play-test (F10) -- each living guard near the eye has its sight laid on the ground as the cone it sees with (yellow, orange alerted, red while it sees its target), the route it has still to walk, and what it is doing over its head (activity and script action), read each frame from the running soldiers (SoldierSnapshot gains the mind's facing, alert, sight, doing and route). Play-test skip holds the cutscene skip for the player; F4 now stands the player facing where the editor's camera looked. The play-test's keys (F2-F4, F6-F8, F10) no longer run their binds while it runs (the developer's renderer toggles, co-op calls). Tags never overlap or cover the banner; the banner is drawn first, as text drawn after a text run and its shadow lost its first glyphs on D3D12
- editor: Play-tests are recorded and played back -- every play-test records, from the level the editor loads for it, the input the player was given each tick, the ticks its cutscene was broken, and the play-test commands that change the game (god, unseen, stood at the camera), each before the tick it came before; F9 loads the level afresh and gives it all again, which puts the player and every soldier where they were tick for tick (PlaytestReplayTests: mission 1, 14 s walked and fired, played back with the window holding nothing, equal at every tick looked at, and again after a seek back). Left/Right go 5 s back or on (back = the level loaded afresh and run up to the moment, on = run at 32x), Home to the start; the scrubber under the banner shows where it is and marks where a guard first saw the player and each command. Quick save/load are off in a play-test. Not recorded: the weapon wheel and the computer's screens. editor wait for scripted runs
- editor: A play-test's recording marks each rule the first tick it runs (the logic watch reads every rule's latch, shown or not), beside the guards' first sightings and the commands
- maps: The community map package -- one file read front to back (OIGIMAP1, manifest, the bytes of every file the map carries), its rules (data only, every file inside its mission's folder, its own mission.qvm, within size, none of the game's own files carried: an unchanged game file is named by path and hash and the player's game gives it back on unpacking, refused if it is not the same), and the per-install publishing identity (ECDSA P-256 kept in the settings folder, signing method, path, time and the body's hash)
- master: Community maps -- /v1/maps on the master server (maps.js, one Maps Durable Object): a map published signed by an installation's key (ECDSA P-256 over method, path, time and the body's hash, ten minutes' grace), its package checked as it arrives against MapRules' twin (data only, inside its mission's folder, its own script, every carried file's hash, none of the game's own files carried and none named falsely, against the hashes we load at /v1/maps/admin/game-files) and up at once; kept in 120 KB chunks; listed by game, downloaded byte for byte; a new version only from the key that first published it; one rating a key (not the author's), one report a key and hidden at five until /v1/maps/admin/restore; taken down by its author or the admin token. maps.test.mjs covers it all; a package written by MapPackage.cs and a request signed by .NET's ECDSA check out here. Not deployed
- maps: The maps client and the installed maps -- MapService (list, download checked against its hash, publish, rate, report, take down, each signed; refusals read as the server's reasons; OPENIGI_MAPS_URL for a local server), MapLibrary (/maps/: the package as downloaded, its listing, its files unpacked once and again only for a newer package, the game's own files a map names read from the game itself), and test/serve-maps.mjs serving maps.js from Node for a local try. Run end to end from C# against it: published, listed, downloaded byte for byte, rated, junk refused with its reason, installed, unpacked, taken down
- maps: Publish from the editor, play in the game -- File > Publish Map (a mission the editor made: its folder packed, each file the game has byte for byte named by the game's path, its name and description written into its own mission.qvm so it does not show its language keys, checked by MapRules with the game's own files known, signed and sent; up at once; ed_map_author kept). The game: maps / map_get / map_play / map_remove ; a map played is unpacked once (the game's own files from the installation itself), laid over the game as a content layer of its own, its mission started from the menu as Play does, and taken off when the mission is let go. Run end to end against the local maps server: a copy of mission 1 published as 2 MB (1400 of its 1402 files named, not sent), installed by another run, played from the menu. Wizard Form/Review shared (WizardParts)
- maps: The game's Maps page -- a Maps tab beside Campaign (header and compact rail): the maps installed here and those published for this game in a list (rating, INSTALLED / UPDATE), the chosen one's name, author, version, rating, downloads, size and summary, Download / Update / Play at a difficulty, your rating, Remove and Report; the work goes through IShellMaps (the host's ShellMaps: MapService and MapLibrary off the frame, a map played from the menu as Play is). Not in the browser build. ShellPageShots draws it (13-maps) at every size
- launcher: A Maps section -- the selected game's community maps, a line each (author, version, rating, downloads, size, summary), downloaded into the game's own maps folder, updated or removed there, played from the game's Maps page; the same MapService and MapLibrary. Sections renumbered (Maps after Mods): Home's settings link, the servers and logs indices; the screenshot test's section list brought up to date (it had no Servers) and its Home-to-Settings switch
- release: Maps game-files --out -- the SHA-256 of every file of the games given (hashes only), for the master server's /v1/maps/admin/game-files: no map may carry one, and none may name a file that is not one. IGI1: 2869 hashes, 190 KB; loaded into the local maps server
- engine: Level checkpoints -- the level held in memory and put back exactly, by identity: StateCheckpoint records every state object shallowly (each type's copy, restore and walk compiled once; readonly fields restored through a DynamicMethod; structs and struct arrays walked, so collections are plain objects), shares unchanged arrays with the checkpoint before, never writes into itself; Differences walks two checkpoints in step for the first fields that differ. SimulationBoundary: the engine's tasks, the script machines, both games' code (not multiplayer or menus), IgiRandom and the bodies' playing animation; NotSimulationState on the mission's voices and a drawn cache. Mission 1 with its intro: 28k objects, 6.5 MB, captured in 650 ms cold / 8 ms after (2 MB its own), restored in 58 ms; 300 ticks played after a restore are the first 300 field for field, twice
- editor: The live cutscene preview seeks back without loading -- a checkpoint each second of the scene's clock (budgeted, every other one let go past 512 MB), a seek back restores the last at or before the moment and plays on at most a second; the level as the editor had it is held before a scene first plays, and ending the preview or turning to another scene puts it back (skip state included) rather than loading the mission. A drag back follows the playhead live (a warm restore is 2 ms). Loading stays only for a mission saved with changes (Finish(reload: true)). CutscenePreviewTests: seeks in any order give the camera played, the same level throughout
- editor: Edits made in the running level stay in it -- TaskScriptCommands.Rebind gives a live task the values of its compiled Task_New call, read by the level's own VM and parameter readers onto a task apart from the tree and moved over by name (MissionDocument.LevelPath / CompileTaskValues); the game reads it again (CutsceneRuntime.Reread: a scene's shots with each link's pose as loaded, an animation's run and keys replayed to where it was, a sound's condition and what it plays, all changed in place); a journal of the changed tasks is laid on again after every checkpoint restore; the preview lets go of the checkpoints from where a change can act (the camera: none) and plays the shown moment again from before it. Checkpoint compare: hash tables as sets, collection bookkeeping and DerivedState indexes skipped; the placement epoch only moves on (moved on after a restore); the expression compile cache left alone. CutsceneLiveEditTests: a shot's camera moved and a cue moved later at 10 s, back to 5 s, on to 16 s = the same mission saved with them and loaded, field for field
- editor: The sequencer keeps playing live through edits, and its lanes stay readable -- a change made while a scene plays live goes into the running level as it is made (IEditorHost.ApplyLiveEdit), from where it can first act: a camera's view never (no replay), a shot's length from the shot, a cue or an animation from the earlier of where it was and is, the scene's settings from its start; a task added, removed or moved still saves and loads. The level is known to hold the document (LevelHoldsDocument), so Play Live no longer saves and loads for changes already in it. Cue lanes laid out by CueLaneLayout: diamonds nearer than 10 px are one mark ('first +N', a dark core), a label never runs past the next mark (cut to its room, or left out), hovering a mark lists its cues with their times, clicking it again picks the next. SequencerPanel's drawing moved to SequencerPanel.Drawing.cs (the file was over 1000 lines). Seen in the editor: mission 2's intro (666) opened at 30 s and taken back to 18 s live, no load
- editor: The play-test's replay goes back without loading -- a checkpoint as a recording's first tick runs and every two seconds of it (CheckpointRing, shared with the cutscene preview: nearest at or before, dropped from a moment, every other let go past 512 MB); a replay, a seek back and a new recording (F9) put the level back from memory and run on under two seconds, the cheats as the recording had them by then; loading again only where nothing is held. PlaytestReplayTests: positions exact, and the same level throughout
- editor: Shots added, taken out or reordered go into the running level too -- IEditorHost.ApplyLiveChildren gives a scene the children the editor has (each shot's camera made afresh as a load makes it, TaskScriptCommands.NewUnder; the rest matched by type in order) through TaskTree.SetChildren, journaled and laid on again after every rewind, the scene's shots read again and the level's tasks numbered again as its load numbers them; the sequencer sends it for Add Shot / Delete Shot / Add Move when every shot is the scene's own child, from the earliest shot changed. Fixed on the way: a task not in a checkpoint keeps its links from before the restore, which SetChildren now clears rather than follows (followed, it emptied the scene of all but its last shot). CutsceneLiveEditTests: a shot added and one taken out at 10 s, back to 5 s, on to 16 s = the saved mission loaded, field for field
- editor: The sequencer shows a scene's dialogue, and what starts with it -- a Voice lane for the scene's lines (sounds of the game's _cut speech, or kept in a voice-over container), unnamed sounds named by what they play (_cut02_03, not ConditionalSound 3002), and cues the scene starts (CutScene_N.isRun, or nTick below a moment with no lower bound) at 0 s: mission 2's first line and its 0-7.8 s container were missing. Retail I.G.I. has no cutscene subtitles (no message is cued in the intro): the dialogue is its sounds. CutsceneModelTests: mission 2's intro read
- editor: A scene's links on the sequencer -- what the mission does about a scene apart from its clock (CutsceneModel.Links): what waits for its end (the next scene, 'Mission complete', what is switched on or off after it) at its end, what goes by whether it plays at its start; a Links lane, each named by what it does, selected by a click (nothing to drag). Audit of the 45 retail scenes: 61 of 596 mentions were not shown, all links; now every one is (CutsceneModelTests checks all 14 missions)
- editor: Pilot a cutscene camera key, as Unreal pilots an actor -- Pilot (toolbar, shot menu, Shift+P) sends the viewport to the key where it is seen (through its shot space, at the moment it starts), with its lens, letterbox and a banner; flying the viewport writes every move back into the key through the same space, its angles the nearest to its own and its roll kept (CameraAngles.Roll / WithRoll: the editor's camera cannot roll), the whole pilot one history step, the running level given it when the pilot ends. Esc stops, [ ] pilot the key before or after, Alt+wheel changes the key's lens, K keys the view into the selected key (or adds one). The editor's viewport now draws a cutscene frame (and a piloted key) with the scene's own lens, as the game frames it; before, it always drew the viewport's ninety degrees. Console: editor pilot [n], editor fly [yaw]
- editor: A scene's camera as moves with keys, as Unreal's Sequencer shows camera cuts with their transform keys -- CutsceneMoves: knots gliding one into the next are one move, a cut ends it; the camera lane draws a clip a move with its keys as diamonds (a knot that only ends a glide is a diamond, not a sliver to miss). A key dragged retimes it, the key before giving or taking the time (Shift ripples the rest); a move's end dragged stretches its keys; a click in a move picks the key there and seeks to the click. Add Key at the Playhead (Shift+K) splits the key there with the path's own values (through it to half a millimetre; the path elsewhere moves at most 0.29 m over a 12.7 m move), Delete Key keeps the later keys' moments, Duplicate Key, Copy/Paste View. The Inspector's Camera Key section: which key of which scene and when, what it rides or watches, lens and turn in degrees, length, glide, and Pilot. Editor.Core references OpenIGI.Game for the shared camera path maths. CutsceneMovesTests: all 45 retail scenes' knots in exactly one move, end to end
- editor: The cutscene camera rig in the viewport, as Unreal draws a camera actor and its motion trail -- each key a camera frustum (its lens across the game's 4:3 picture, the top edge marked), numbered, a line to what it watches; the path ticked every half second for speed; live, the keys riding what the shown key rides drawn where they fly now, teal, relative to the ride at the playhead (a trail in its space), with a note saying so. A click on a key's camera selects it and seeks to it; the move and rotate handles work on a key where it is seen and write back through its shot space, its angles the nearest to its own (rotate now works on cameras: their turn is three angles, not one orientation). SequencerPanel's path moved to SequencerPanel.Rig.cs; the shared CutsceneMoves.KeyOf replaces the panel's own
- editor: Ease a cutscene camera key, baked into keys the game reads -- the game's camera path is an automatic cubic through its knots with nowhere to keep tangents, so an ease (in, out, in and out, even speed) keeps the way and changes only its timing: helper knots on the original path at moments a cubic ease spaces, and one a tick from the key it rests at, the game's tangent there shrinking with the time to its nearer neighbour. Helpers are labelled ·ease, the first keeping the ease and the key's own length as written, so Remove Ease gives the mission back byte for byte; the lane draws them as the key's ease band, the viewport does not draw them as cameras, a click on one picks its key. Shot menu and Inspector: Ease. CutsceneMoves.KeyAt is the shared key-on-the-path. CutsceneEasingTests: mission 1's helicopter shot eased out arrives at 1.8% of its mean speed, never more than 1.3 cm off its way, and comes off exactly
- editor: The cutscene camera's curves, as Unreal's curve editor in small -- Curves (sequencer toolbar) opens a view under the camera lane: speed (m/s), turn rate (deg/s), or a value the game blends (X, Y, height, the three turns, the lens), read off the game's own path, the keys' moments faint behind it; a key's dot dragged up or down writes its value on that channel (CutsceneCurves). Eases now follow their keys: a key moved by the handles, the curves or the Inspector, or flown by the pilot (once, as it ends), bakes the eases next to it again in the same undo step (CutsceneEasing.WithFollow/Following). Tests: every value curve passes through every key of mission 1's scenes; a set value reads back; an ease's helpers after the key it runs to is lifted are where a fresh bake puts them
- editor: Cutscene camera rigs baked into keys, as Unreal's rail and crane rigs and Cinemachine's dolly track -- Add Move offers a Rail (clicked out on the ground in the viewport: Enter makes it, Backspace takes a point back, Esc stops), watching the selected object or looking along the way, and a Crane or an Orbit round it; the old push in, fly-over and pan stay. A rig's keys are plain EditCamera knots labelled with its name, so the mission plays in the original game; its settings are the editor's own (rigs/.rigs.json beside the project's files, saved with the mission, changed only through the history so undo puts a rig back with its keys). The Inspector's Rig section changes length, height, reach, rise, swing and start, each making its keys again in their place; keys edited by hand are noticed by fingerprint (Make Again from the Rig, or Plain Keys). A rail's bends are rounded as a dolly track is laid and its spans timed by the game's own curve, so it flies at one speed: 7.9-8.6 m/s round a right-angled 70 m track in 8 s (6.9-9.7 with sharp corners). CutsceneRigsTests: speed, a crane watching its subject within 2.6 degrees, remaking in place, hand edits noticed, the sidecar read back, the mission saved as plain knots that read back. The camera wiring moved to EditorSession.Camera.cs
- igi2: Bird flocks are drawn
- accounts: Link a player's key to Discord, one request signer for maps and accounts
- master: The owner's stats list every room, private ones too
- accounts: An install's account kept frame by frame: checked, linked through Discord, unlinked
- profile: One operative, signed into with Discord
- profile: The profile follows the player through their account
- master: Match results from the listed servers, records and season boards
- stats: Dedicated servers report decided matches; the profile shows the record
- master: A board for a season gone by, named by its month; results ordered by arrival
- presence: What the player is doing, on their Discord profile
- site: The official servers' leaderboard and each player's record
- master: Discord's Linked Roles follow the player's record
- master: Rooms that carry the game, for Discord Activities
- net: A room can carry the game itself, where WebRTC isn't allowed
- web: Play inside a Discord Activity
- web: Inside a Discord Activity the player plays under their Discord name
- launcher: Sign in with Discord from the launcher, and the game is signed in too
- launcher: An account menu in the header, with the player's avatar and a proper sign-out
- account: The player's Discord avatar and name from the first frame, on shared parts
- stats: Medals, the player page, privacy, and a deleted account's record goes with it
- launcher: I.G.I. 2 is playable from the launcher, its folder no longer marked optional
- menus: Hide the Maps tab in the launcher and the game for now
- launcher: The Servers page laid out and drawn as the game's Multiplayer page, on shared parts
- launcher: No Host tab; maps named and pictured on the Servers page as in the game
- servers: Official servers marked in the game's and the launcher's server lists
- servers: Official servers carry the verified badge, a scalloped seal with a tick
Fixes
- igi1: Mission 6's fuel tanks take their charge from any side, as a charge spot is offered by the view and its own radius, not by the way it faces (0x4389E0)
- render: A helicopter's rotor is the blended smear of its blade under every preset -- the two blade textures were listed as glass panes, so outside the original's look each copy of the blade was drawn as a solid mirrored sheet and the disc as a fan of dark wedges; they are off the glass list, and the rotor pass draws no pane whatever a texture is listed as (0x42C630)
- launcher: The launcher carries the stronger body face the menus now ask for -- it loads every face of the design and the new one was not beside it, so it would not have started; the display's tests are handed the same face
- release: A single-file package leaves out a native library's debug symbols -- SkiaSharp's Windows package now carries libSkiaSharp.pdb, which stood beside the launcher's one file and stopped its packaging
- web: A browser joins a server on a map it has not yet played -- a server's list of files is checked once that map's own files are where the game reads them, the asking being what fetches them, where a list for a level still to be fetched was refused for a file the game did not have
- web: Search and destroy draws in a browser -- a bomb site's marker took its edges' widths behind a branch on what a vertex carried and after pixels past the rim had left, which WGSL forbids of a screen-space derivative; WebGPU refused the shader and with it every frame a site was drawn in, so the picture stood still; the disc is now worked out for every pixel and masked at its rim
- mp: The bomb is in its carrier's hand again -- the player's own body and arms sets are read with the clips the game adds to its sets, as they were before the player moved to the title path; read bare, the arms had no clip to hold or plant the charge with, so it was not drawn
- mp: Teams stay true -- a free-for-all's scoreboard is never split into IGI and Conspiracy, and the world's sides follow the match's
- editor: The editor asks the engine what a level may hold -- each game lists its own area criteria with what each counts, where one wrong list of three served both; a new mission's name goes into every language's mission texts under a key of its own, as the original's menus look names up, where the name written as words showed as a missing key; the game's fixed task lists, read from where the original fills them, are in the title's vocabulary and a mission past one is an error before it stops the game; a level with no player, a guard generator that is not one soldier, and a soldier's mind without its script are found; a graph node's criteria joined with | give it every bit, as the original evaluates the text
- game: Project I.G.I. cutscene filters draw in their colour -- a shot's filter colour and hour were read under names no level declares ("Filter color RGB", "Time of day"), so every band and line filter came out black where 59 retail shots give it a colour (night-vision green and the like); they are read under the levels' own names, as the original reads them by their place in the EditCamera table (editcamera.c). The hour changes nothing: every retail shot leaves it at -1.
- editor: The sequencer reads a shot's Smooth to next as the levels spell it -- TRUE and FALSE were read as numbers and failed, so the preview cut between every retail shot the game glides through, and the shot menu offered to glide into shots that already do; editor shot opens a shot's menu from the console
- game: A Project I.G.I. save read onto the level runs its vehicles from the tick it was made -- the vehicles' once-a-tick guard kept the tick each last ran on, so one whose last run fell on the tick a save set the clock back to was passed over on it; it is forgotten as the walk's clock is read. And a vehicle read from a save has not stepped in the tick it is read on, so what rides it takes its pose as the level placed it, not as a run that never happened in this timeline left it
- editor: Play-test replay keys -- Esc leaves a replay (it waited for the intro cutscene, which a held replay never ends; and now waits only for a scene the player can skip), F6 at the recording's end plays it from the start (it let one tick through and stopped, so it stepped, and ran the clock past the end), F7 there goes nowhere, the level held at the end; a recording counts the ticks run, not frames that looked at one (paused frames added ticks: 0:06 / 0:05). Banner: Replay ended / F6 from start, F9 play live
- mp: Teams stay true -- a free-for-all's scoreboard is never split into IGI and Conspiracy, and the world's sides follow the match's
- editor: A view written into a riding shot is seen where the viewport was -- CutsceneShotSpace (OpenIGI.Game) is the riding maths once: the game builds a riding key's frame with ToWorld (retail sub_508940, CutsceneCameraFrames), the editor writes its view back with ToAuthored through the space the shown frame used (kept with the frame, so a ride taken once is written through the pose it took; IEditorCutscenePreview.ShotSpace); CameraAngles.Closest writes a turn as the angles nearest the key's own, both Euler solutions and whole turns tried, as Unreal's pilot keeps rotation winding (SetClosestToMe), so the game's per-angle blend never turns the long way. Set to View and Add Shot from View go through both. Tests: round trips and winding; mission 1's insertion played live on a ride, the shown camera written back lands 0.001 units from the path as written
- editor: A live edit that changes how many tasks stand before the player recounts the player's place in the walk -- Igi1MissionTick cached it as the level's walk was set up, so nine ease helper keys baked in live left it nine short of what a load counts (272 vs 281), and the gun rounds marched before and after the player would split in the wrong place. RecountPlayerOrder after every reread scene. CutsceneLiveEditTests: an ease baked in live equals the mission saved with it, field for field (the add-and-remove test kept the count, which hid it)
- editor: What the cutscene camera captures showed -- a key is piloted, picked and seeked a moment into it (at its very start the game's frame is still the key before's, so a riding key was flown as written and a watching one stared at the sky); a watching key's pilot opens on the game's own frame (IEditorCutscenePreview.CameraShown). The pilot banner sits under the view's chips, the rail hint above the rig's note (now on a chip), key numbers never drawn over each other, the path broken at a cut instead of drawn across it, a key framed and marked where it is seen, a watch line to where its ride is now. Keys numbered by their own count everywhere (lane, banner, Inspector, editor key/pilot), the ease named in the clip, not over it. Speed and turn rate measured on one side of a cut (it read 107 km/s), from nought up. Eases shape the way covered with a flat key tangent (smoothstep: 1.50x the mean pace; quadratic for one end), helpers on the scene's millisecond grid so the span keeps its length (rounding had it end past a cut, a 3.4 km jump), twelve steps and closer helpers toward a resting key (arrives at 1.9% of its mean pace). A new rig is its own shot, cut to and cutting out. An ease made live no longer falls back to saving and reloading (a step built by trying its parts puts a shot in, out and in again); the fallback says why when it happens. Console: editor key/ease/curves/rail/rig/camera
- igi2: What a conditional container holds out of the world is out of it; cutscene figures play their clips
- igi2: Mission countdowns are drawn; what leaves the world stops its sound, its overlay and its rain
- igi2: Doors, vehicles, squads and smoke leave the world as retail's remove handlers take them
- igi2: The inventory key hides the inventory, as the profile option does
- igi2: Status messages wrap into the lines their box shows
- igi2: Objects excluded from portal clipping are no room's, so no room hides them
- igi2: What wears the model "none" is neither drawn nor met
- igi2: I.G.I. 2's glazing is drawn as glass, not cut into grey blots
- render: A pane's texture reaches the opaque world only where it is solid
- render: Stained panes keep their dirt off the original's look
- igi2: Action icons named through the status screen's alias are drawn
- igi2: Finishing an action no longer flashes the last kill's mark
- igi2: Trains carry what rides them -- their switch, their props, their guards
- igi2: An explosion smokes
- ui: A canvas measures each child in the room its anchor gives it
- profile: Each game keeps its own campaign progress
- web: Inside a Discord Activity the game starts by itself, no Play to press
- presence: The first frame no longer overflows the presence timer and stops the game
- web: A Discord Activity opens the menu, and signs the game in
- launcher: The sign-in shows on the top strip at every size, never greyed out
- launcher: The account panel floats over a dimmed page instead of merging into the news card
- account: Say plainly what signing in brings, cloud sync first
- profile: No list of an earlier version's profiles
- profile: Signed in, the player is shown and plays by their Discord name
- master: Embed medals.js in the self-hosted config, and a test that every module is
- host: The F12 panel loads for every title, so it toggles in I.G.I. 2 too
- Work off the frame goes through the work scheduler; no other product named in comments
- generators: Task docs are emitted where a build keeps no documentation
Performance
- editor: The map's scene no longer holds the frame -- what reads the running level (terrain patches, placements, texture files, collision) is gathered a few milliseconds a frame (mission 1: 126 frames, the longest 22 ms), and the atlas and textures' decoding, the ground's index and every face's ground are worked out off it (0.9 s). The terrain export walks a patch a step and frames the box at its top, so any ground under it is taken in without sampling its heights; the sink takes atlas tile numbers, the tiles decoded by the caller
- igi2: The terrain quadtree reads its tile by reference and keeps a still view's mesh
- igi2: The crosshair, the drawn models and the AI stop redoing a tick's work every frame
- render: No per-frame garbage in D3D12 submission and binds; LOD levels no longer leak
- igi1: Bone turns, the look-ahead pose, agent lookups and input bindings allocate nothing per frame
Changes
- editor: One writer of guard scripts -- the editor's own pair of scripts is gone; a new Project I.G.I. guard gets the levels' own guard script (level 1's ai/2226.qvm, kept in the engine's AiGuardScript) with its orders put in where its guards' are, which for a patrol is level 1's ai/2203.qvm byte for byte; on save a patrol laid with the patrol tool is started, and one taken away stopped, in the soldier's own script and nowhere else, as every other order is
- game: The cutscene camera path is shared engine code -- CutsceneCameraMath (now in OpenIGI.Game, public) evaluates a scene's camera at a moment from its keys (the knots flattened as 0x4F4880 does, the last start not after the time, each channel on 0x4F55D0's Hermite, smooth-to-next honoured), and the game's cutscene frames are built on it, drawing every traced frame as before; the editor previews the scene being edited with the same function
- launcher: Mission names are the title's own, not written down by the game
Downloads
The easiest way to play is the OpenIGI Launcher (openigi.com or its releases), which installs this build for you once its update channel is set to Beta. To run the game yourself, each build comes in two flavours: self-contained runs on any machine, and .NET is a fraction of the size but needs the .NET 10 runtime installed.
| Self-contained | Needs .NET 10 | |
|---|---|---|
| Windows | openigi-game-0.6.9-beta.1-win-x64.exe | openigi-game-0.6.9-beta.1-win-x64-dotnet.exe |
| Linux | openigi-game-0.6.9-beta.1-linux-x64 | openigi-game-0.6.9-beta.1-linux-x64-dotnet |
| macOS (Apple silicon) | openigi-game-0.6.9-beta.1-osx-arm64.tar.gz | openigi-game-0.6.9-beta.1-osx-arm64-dotnet.tar.gz |
Windows and Linux builds are a single executable (on Linux, chmod +x it first). macOS builds are an app in a tarball.
On macOS and Linux, the launcher installs with one command: curl -fsSL https://openigi.com/install.sh | bash.
The macOS builds are not notarized, so macOS reports an app downloaded with a browser as "damaged"; clear that with xattr -dr com.apple.quarantine "/Applications/OpenIGI Launcher.app" (or the app's path).
OpenIGI needs your own copy of Project I.G.I.; it ships none of the game's data. Verify a download with sha256sum -c SHA256SUMS.
Dedicated server: openigi-server-0.6.9-beta.1-linux-x64.tar.gz (sudo ./install.sh) or openigi-server-0.6.9-beta.1-win-x64.zip (.\install.ps1); it plays your own copy of the game too.
On ARM hosts: openigi-server-0.6.9-beta.1-linux-arm64.tar.gz or openigi-server-0.6.9-beta.1-win-arm64.zip, installed the same way.
0.6.8
Full changelog
New
- mp: How long a round's result shows before the next is a server setting, mp_roundendtime (5 s), and after the bomb goes off mp_bombendtime (now 10 s, was 20)
- master: /v1/stats lists the dedicated servers by name, mode, map, players and version, and counts a server's own room as the server rather than a public room too
- igi2: The remastered computer's map marks the objectives, the level's highlights with their labels and the hostile humans as it does in Project I.G.I., from one mark type and one choice in the host of whose computer it shows
- igi2: The sequel's lamps are read from what its models and its bake say of them -- a model's glows are drawn as the original draws them on its own look, a soft sprite over each lamp, and on the others each becomes a light where it stands with its glass lit; a lamp with no glow is found by the page a glowing one wears or by the flat mid-grey the bake lays over a surface that lights itself; baked geometry, which stores no normal, is given the normal its faces have, so a room of it takes light at all; and a lamp under a mountain counts as under a roof, where it stood in the open and was out all day
- saves: The save engine moves to OpenIGI.Game and follows retail's rules -- pickups, the player's weapons and the task census match retail's own saves
- saves: A hosted mission can offer save games, and Project I.G.I. has the start of its own -- off until the whole level is kept
- saves: Project I.G.I.'s world keeps its state -- lifts, doors, switches, pickups, sirens, cameras, what breaks, what turns, and the level's objectives and messages
- saves: Project I.G.I.'s soldiers keep their state, I.G.I. 2's way -- body, health, rounds, where the mind stands and the patrol it was on
- saves: Project I.G.I.'s player keeps its state -- where it stands and looks, its health, what it carries and the rounds in each, and the mission's counts
- saves: Project I.G.I.'s level walk keeps its state -- containers, timers, animations, sounds, cut-scene verdicts and where the vehicles stand -- with the streams of chance, minefield waits and car glass
- saves: Quick save on F5 and quick load on F9 for both titles, and a mission that cannot be played on from is not saved
- saves: Project I.G.I.'s save games are on -- checked in the game and on all fourteen missions
- saves: Project I.G.I. keeps the mines it has laid and the grenades whose fuses are running
- saves: The quick save and quick load keys are bindings of the profile, F5 and F9 until the player chooses others
- saves: A mission is saved from the player's computer, as I.G.I. 2 saves, and no longer from the pause menu
- igi1-saves: A save is read onto the level that is up, as I.G.I. 2 loads, and the mission is no longer brought up again
- computer: The remastered computer is a satellite feed in the heads-up display's own look, with the original's sounds
- touch: A touch screen's layout is the player's to arrange, over three saved layouts, and its buttons are drawn from baked icons
- master: The master server runs self-hosted, on workerd behind Caddy, beside its Workers deployment
- tasks: Typed task events sent through the tree's own walk, task references that empty on delete, and the engine's task list
- igi2: Generators run -- one power rule for both titles' Generator task
- igi1: Project I.G.I.'s content can be read from its install for its soldiers in another game's level
- igi2: Another game's soldiers can stand in an I.G.I. 2 level
- igi1: Project I.G.I.'s soldiers can run in another game's level
- igi1: The soldiers of a hosted level are drawn by the game's own renderer
- igi2: Another game's player can stand for I.G.I. 2's
- igi1: Project I.G.I.'s player can stand for another game's player
- modding: An I.G.I. 2 mission loads headless for a mod's tests, its level brought up as the game's
- igi1: Project I.G.I.'s guards and player stand in I.G.I. 2's levels, drawn and heard as the game's own
- igi1: The guest's guards and player are heard, textured and drawn as the game's own, its player dies to a death camera
- igi2: Radios chatter, on the rule both games share
- igi2: Rotating objects turn, on the rule both games share
- touch: The fire button shows a bullet
- menu: The multiplayer page reads by colour, shows the map, and keeps its place
- menu: The server list shows skeleton rows while it loads, and a server that doesn't answer can't be joined
- console: Death_test kills the player, and campos names the sector
- render: An OpenGL 4.3 backend, for a PC with neither Vulkan nor Direct3D 12
- render: Every IGI 2 mission has its own look, so its nights stay dark and its days match the original
- controls: The third-person view and the co-op keys are on the Controls page, and can be moved to another key
- controls: The sight is on the right mouse button, the weapons on the wheel, and leaning out and the zoom on keys a laptop has
- computer: The remastered map is worked with fingers -- one drags it, two pinch it, a tap opens a page -- and is sized for a phone's screen, where it is drawn without the visor's layer
- menu: The menus are laid out for the screen they are on -- a monitor, a laptop, a phone on its side -- with larger type and controls, a landing page that continues the campaign, and a phone's notch kept clear
- menu: Every page follows the design -- text at the design's own sizes, multiplayer's header, list and side panel as drawn, the quality preset as a bar, bindings named and grouped with a search, the profile's saves along its foot -- and a profile can be renamed, its saves going with it
Fixes
- igi2: A fence panel turns by its heading, the one angle it carries, where every panel had faced down the world's X axis and a run along Y stood across itself
- igi2: What a conditional container holds leaves the world when it stops, neither drawn nor met, so mission 4's cutscene helicopter no longer stands beside the one that flies off; a part that turns keeps turning on an object that moves, and a moved prop carries its figures, smoke, sounds and props with it and stands still once it stops
- igi2: A terrain tile draws none of the ground a finer tile inside it draws, and the two meet along one line -- the coarser tile's own samples round the finer one at their true heights, the finer tile's edge held to the straight lines between -- where a sample of overlap showed as a pale square on mission 4's far hillside
- master: A joiner's signalling is held to a rate and an address to so many joins a room and parties a minute, the host's own socket to none; a party member the leader removed is kept out by its address too, and a party's token is read from a header as well as the address asked
- mp: Netcode audit -- a bare acknowledgement no longer stands for the last packet's reliable messages; events reach every client once, sent until acknowledged; a view tick is counted from the newest snapshot held; a snapshot too large for its packets goes whole by the reliable channel (protocol 21)
- igi2-saves: Mines are kept and made again by a load, generic pickups are written against their parents, and a body's flags and the state before its own come back as saved
- igi2-saves: A load takes the messages off the screen and empties the computer's log first, as Game_LoadFromSlot does
- igi2-saves: A mounted gun keeps its weapon, written against it as retail writes StationaryGun/WeaponHandler
- computer: The original computer's pointer no longer sticks when the hidden desktop pointer reaches the edge of the screen
- saves: No save game is made, read, listed or carried over in a multiplayer session
- igi1-saves: A siren raised after a save stops as that save is loaded
- ui: Small text is drawn from an atlas of its own size, and the menus are drawn no smaller than they can be read
- igi1: A StatusMessage runs no child, as the original's handler does not (0x485890)
- sdk: The mod test fixture registers the level's task classes, as the game's content does
- igi1: An ExplodeObject, and the types built on one, run their update where the level's walk reaches them (0x481970)
- igi1: A Radio runs its update where the level's walk reaches it, after its ExplodeObject's (0x43AF90)
- igi1: A Smoke adds its particles where the level's walk reaches it, before they are stepped (0x437DB0)
- igi1: The title player's look between ticks is handed over as axes in columns, as the presenter reads it
- igi1: On the title path the eye and the arms are drawn from the look gathered since the last tick
- host: A title's player is steered by a script's input, and held still under a menu that does not pause
- core: The log file's writer thread outlives a close that did not wait for it
- tests: The three tests that were red are green
- host: The world's effects draw from the played mission's stream
- igi1: What the player threw and fired runs where the level's Dynamic tasks run, after its objects
- igi1: A Siren is an ExplodeObject -- its damage, its blast and isExploded are that object's
- igi1: What the original does in a task's own run is done there, not in a pass after the walk
- igi1: A round is marched by its gun's GunShot task, and what the level makes while it runs runs at Dynamic's tail
- mp: A fallen player holds no gun, and a climbing one is hit where it is drawn
- mp: A dedicated server opens a new room when its room is gone
- igi1: A dead player still stands in its areas
- igi1: The death camera tests its body points 716.8 out, as 0x483A00 does
- igi1: The player's corpse keeps its height where no ground is found, as a soldier's does
- menu: The main menu keeps the cursor free over a level that was left
- igi1: A soldier's sight line is hidden by anything solid wherever it stands, a door at the target included
- tests: A dead player still counts in its areas, and vehicle arming reads its tasks by class
- tests: The shading agreement test hands the shading a lamp grid, as a frame with no lamps does
- render: A renderer switch builds the game that was running, not the one the process started on
- launcher: The game is told where every other game is installed, so the main menu can change to it
- render: An IGI 2 lift, door or train is drawn from inside a building, as only interior objects take the room test
- render: A model bent along a track or wire stays two-sided, so the IGI 2 train tunnel has its walls from inside
- ci: The shader check finds SPIRV-Cross on Ubuntu, as the tool opens it by its path
- web: Escape pauses instead of dropping the page out of fullscreen, and the mouse is taken back after it
- web: The browser build keeps a setting changed on the Gameplay page, as its preset is applied before the saved file
- web: The game no longer runs fast after its tab was hidden, as the time away is left out of the schedule
- igi1: A click or a wheel notch shorter than a tick is no longer lost, as a press between two ticks counts for the next
- igi1: A player wedged in mid-air no longer dies on touching down, as a fall that is held up keeps only the speed it moves at
- igi1: Mission 14's sentry guns have their dome, as a gun holder's own model is placed (0x46E7F0)
- touch: The game no longer stops the first time a touch screen draws its buttons, as their icons' pixels are made outside the loader the browser interprets
- igi1: Mission 6's fuel tanks take their charge from any side, as a charge spot is offered by the view and its own radius, not by the way it faces (0x4389E0)
- render: A helicopter's rotor is the blended smear of its blade under every preset -- the two blade textures were listed as glass panes, so outside the original's look each copy of the blade was drawn as a solid mirrored sheet and the disc as a fan of dark wedges; they are off the glass list, and the rotor pass draws no pane whatever a texture is listed as (0x42C630)
- launcher: The launcher carries the stronger body face the menus now ask for -- it loads every face of the design and the new one was not beside it, so it would not have started; the display's tests are handed the same face
Changes
- saves: The slots, the rules and a mission's save games are shared -- I.G.I. 2 keeps only its load list, its carry-overs and its computer's labels
- saves: The tasks' own save states are an object a context makes, not a static instance
- flow: EditVariable is one task class for both titles, run by the level's own run
- flow: LevelTimer is one task class for both titles
- flow: AreaActivate is one task class, counting by criteria its level's humans and vehicles register
- flow: LevelFlow is one task class, run where the level's walk reaches it
- flow: DefineComputerObjective runs itself, on a handler both titles share
- flow: Project I.G.I.'s StatusMessage is a task that runs itself; the screen's list only shows it
- ambience: Project I.G.I.'s AmbientArea is a task that runs itself
- tasks: A type's behaviour can be its task's before its parameters are a class's; AlarmControl runs itself
- objects: Doors, cameras, rotating objects, pickups and the things worked by hand run from their own tasks
- cutscenes: The vehicles, animations, sounds and scenes a level's story runs are tasks that run themselves
- tasks: Humans, guard generators and lifts run from their own tasks; nothing binds work to a task's node
- level: The level's run has no table of work bound to tasks
- tasks: Static and Idle have classes of their own, and a level's run tells its containers by class, not by name
- objects: MineField is one task class, run where the level's walk reaches it
- render: The world renderer asks the title's objects through one contract, and names no door, lift, camera or cut-scene
- host: The host ends a mission, sounds its vehicles and forces a test outro without naming the cut-scene or objective runtimes
- mission: The shared mission state holds no IGI1 runtime; the host reads its cut-scenes, objectives and objects through contracts
- objects: Each interaction type is a task class that orders its own run
- objects: Door, rotating-object, lift and camera tasks hold the object they are; no registry searches for a task's state each tick
- objects: Each interaction task runs its own type's update by name
- vehicles: A level's vehicles are their own module, and their tasks run through it, not through the cut-scenes
- vehicles: The vehicle classes are named for what they are, not for the cut-scenes
- level: The transforms of the tasks a level moves are the level's, not the cut-scenes'
- vehicles: A CarAI task holds the car and route it drives
- level: One expression runtime for a level -- what is built for it compiles and evaluates through the level's, not one of its own
- hosting: The shared hosting contract asks only what the host calls
- hosting: The level build context names no title's runtime; a title's systems keep what they hand one another by type
- objects: A door's parameters are members of its task class, which the door registry reads
- objects: A lift's parameters are members of its task class, which the lift registry reads
- objects: The parameters of a rotating object, a camera, a camera control and a generator are members of their task classes
- level: The soldiers' guard generators and alarm controls and the computer's highlights evaluate through the level's expressions
- objects: The parameters of the things worked by hand are members of their task classes
- objects: The parameters of an AnimTask, a ConditionalSound, a CarAI and a mounted-gun holder are members of their task classes
- cutscenes: An AnimTask and a ConditionalSound hold what they play; the cut-scene runtime no longer looks a task up to run it
- cutscenes: A CutScene task holds the scene it plays
- vehicles: A car and a helicopter are one kind of task with its own members: the fire gate, the view cone, the door
- igi1: An alarm control's three expressions are members of its task class, and only a task of that class is one
- igi1: The soldiers are stood by their simulation, and the renderer only draws them
- igi1: The soldiers are armed and their tick closed by their simulation
- ai: One guard's orders and script for both games
- igi1: The player's rig is made, tuned and armed whichever level it stands in
- Guest levels and title players share their ids, hooks and Smooth Motion look
- igi1: The player can be ticked and turned from a title path's input
- igi1: The player's life is its own, not the mission's
- igi1: The player is hurt and dies as itself, in whatever surrounds it
- igi1: The player's rounds meet the level's bodies through one shot, wherever it stands
- igi1: One set of rules hurts every player -- the mission's own, a co-op partner and the game's player in another game's level
- host: Project I.G.I.'s mission can stand its player on the title path, and the host's player reads go through it
- host: The computer, the ladder orbit, the rockets' trails and the cheat's hand read the mission, not the hosted player
- igi1: GenericPickup, AlarmLight, Siren, Plane and Train have task classes
- host: Project I.G.I.'s missions stand their player on the title path, and the host loses IHostedPlayer
- hosting: A hosted mission is what makes its level's player
- hosting: Each game is played on its own mission, and Project I.G.I.'s is no longer made for another game
- host: The host holds one thing for the game being played, its mission
- level: A level's run is always the level's own
- igi1: One flag says the level's objects update in its walk
- engine: The count of placement claims is the task tree's, not the process's
- igi1: The map computer's gate and its highlights read the level's own expressions
- igi1: The vehicles' sounds tell a car, a helicopter, a plane and a train by class
- igi1: A soldier's task holds the bodies it runs, and the walk reaches the level's runtime tasks at Dynamic
- igi1: A human's run handler runs its children, and the child that drives it runs its update
- igi1: A soldier's Gun is a task that runs its weapon's clock, ahead of the soldier's update
- igi1: The first game's runtimes live in its own project, and the level has one path
- Vehicle arming has a class of its own, and unused usings are gone
- Dead code, redundant operators and self-modifying loops are gone
Contained
- One way to call code the engine does not own, its failure logged; GameEvents uses it
- One way to call code the engine does not own, its failure logged; GameEvents uses it
- One way to call code the engine does not own, its failure logged; GameEvents uses it
merge
- Project I.G.I.'s soldiers can run in another game's level, on the retail-shaped task model
- Project I.G.I.'s player can stand in another game's level, beside co-op's players
- Project I.G.I.'s mission can stand its player on the title path, behind g_mission_title_player
- Project I.G.I.'s missions stand their player on the title path, and the host loses IHostedPlayer
Downloads
The easiest way to play is the OpenIGI Launcher (openigi.com or its releases), which installs this build for you. To run the game yourself, each build comes in two flavours: self-contained runs on any machine, and .NET is a fraction of the size but needs the .NET 10 runtime installed.
| Self-contained | Needs .NET 10 | |
|---|---|---|
| Windows | openigi-game-0.6.8-win-x64.exe | openigi-game-0.6.8-win-x64-dotnet.exe |
| Linux | openigi-game-0.6.8-linux-x64 | openigi-game-0.6.8-linux-x64-dotnet |
| macOS (Apple silicon) | openigi-game-0.6.8-osx-arm64.tar.gz | openigi-game-0.6.8-osx-arm64-dotnet.tar.gz |
Windows and Linux builds are a single executable (on Linux, chmod +x it first). macOS builds are an app in a tarball.
On macOS and Linux, the launcher installs with one command: curl -fsSL https://openigi.com/install.sh | bash.
The macOS builds are not notarized, so macOS reports an app downloaded with a browser as "damaged"; clear that with xattr -dr com.apple.quarantine "/Applications/OpenIGI Launcher.app" (or the app's path).
OpenIGI needs your own copy of Project I.G.I.; it ships none of the game's data. Verify a download with sha256sum -c SHA256SUMS.
Dedicated server: openigi-server-0.6.8-linux-x64.tar.gz (sudo ./install.sh) or openigi-server-0.6.8-win-x64.zip (.\install.ps1); it plays your own copy of the game too.
On ARM hosts: openigi-server-0.6.8-linux-arm64.tar.gz or openigi-server-0.6.8-win-arm64.zip, installed the same way.
0.6.8-beta.2
Full changelog
New
- render: An OpenGL 4.3 backend, for a PC with neither Vulkan nor Direct3D 12
- render: Every IGI 2 mission has its own look, so its nights stay dark and its days match the original
- controls: The third-person view and the co-op keys are on the Controls page, and can be moved to another key
- controls: The sight is on the right mouse button, the weapons on the wheel, and leaning out and the zoom on keys a laptop has
- computer: The remastered map is worked with fingers -- one drags it, two pinch it, a tap opens a page -- and is sized for a phone's screen, where it is drawn without the visor's layer
- menu: The menus are laid out for the screen they are on -- a monitor, a laptop, a phone on its side -- with larger type and controls, a landing page that continues the campaign, and a phone's notch kept clear
Fixes
- tests: The shading agreement test hands the shading a lamp grid, as a frame with no lamps does
- render: A renderer switch builds the game that was running, not the one the process started on
- launcher: The game is told where every other game is installed, so the main menu can change to it
- render: An IGI 2 lift, door or train is drawn from inside a building, as only interior objects take the room test
- render: A model bent along a track or wire stays two-sided, so the IGI 2 train tunnel has its walls from inside
- ci: The shader check finds SPIRV-Cross on Ubuntu, as the tool opens it by its path
- web: Escape pauses instead of dropping the page out of fullscreen, and the mouse is taken back after it
- web: The browser build keeps a setting changed on the Gameplay page, as its preset is applied before the saved file
- web: The game no longer runs fast after its tab was hidden, as the time away is left out of the schedule
- igi1: A click or a wheel notch shorter than a tick is no longer lost, as a press between two ticks counts for the next
- igi1: A player wedged in mid-air no longer dies on touching down, as a fall that is held up keeps only the speed it moves at
- igi1: Mission 14's sentry guns have their dome, as a gun holder's own model is placed (0x46E7F0)
- touch: The game no longer stops the first time a touch screen draws its buttons, as their icons' pixels are made outside the loader the browser interprets
Downloads
The easiest way to play is the OpenIGI Launcher (openigi.com or its releases), which installs this build for you once its update channel is set to Beta. To run the game yourself, each build comes in two flavours: self-contained runs on any machine, and .NET is a fraction of the size but needs the .NET 10 runtime installed.
| Self-contained | Needs .NET 10 | |
|---|---|---|
| Windows | openigi-game-0.6.8-beta.2-win-x64.exe | openigi-game-0.6.8-beta.2-win-x64-dotnet.exe |
| Linux | openigi-game-0.6.8-beta.2-linux-x64 | openigi-game-0.6.8-beta.2-linux-x64-dotnet |
| macOS (Apple silicon) | openigi-game-0.6.8-beta.2-osx-arm64.tar.gz | openigi-game-0.6.8-beta.2-osx-arm64-dotnet.tar.gz |
Windows and Linux builds are a single executable (on Linux, chmod +x it first). macOS builds are an app in a tarball.
On macOS and Linux, the launcher installs with one command: curl -fsSL https://openigi.com/install.sh | bash.
The macOS builds are not notarized, so macOS reports an app downloaded with a browser as "damaged"; clear that with xattr -dr com.apple.quarantine "/Applications/OpenIGI Launcher.app" (or the app's path).
OpenIGI needs your own copy of Project I.G.I.; it ships none of the game's data. Verify a download with sha256sum -c SHA256SUMS.
Dedicated server: openigi-server-0.6.8-beta.2-linux-x64.tar.gz (sudo ./install.sh) or openigi-server-0.6.8-beta.2-win-x64.zip (.\install.ps1); it plays your own copy of the game too.
On ARM hosts: openigi-server-0.6.8-beta.2-linux-arm64.tar.gz or openigi-server-0.6.8-beta.2-win-arm64.zip, installed the same way.
0.6.8-beta.1
Full changelog
New
- mp: How long a round's result shows before the next is a server setting, mp_roundendtime (5 s), and after the bomb goes off mp_bombendtime (now 10 s, was 20)
- master: /v1/stats lists the dedicated servers by name, mode, map, players and version, and counts a server's own room as the server rather than a public room too
- igi2: The remastered computer's map marks the objectives, the level's highlights with their labels and the hostile humans as it does in Project I.G.I., from one mark type and one choice in the host of whose computer it shows
- igi2: The sequel's lamps are read from what its models and its bake say of them -- a model's glows are drawn as the original draws them on its own look, a soft sprite over each lamp, and on the others each becomes a light where it stands with its glass lit; a lamp with no glow is found by the page a glowing one wears or by the flat mid-grey the bake lays over a surface that lights itself; baked geometry, which stores no normal, is given the normal its faces have, so a room of it takes light at all; and a lamp under a mountain counts as under a roof, where it stood in the open and was out all day
- saves: The save engine moves to OpenIGI.Game and follows retail's rules -- pickups, the player's weapons and the task census match retail's own saves
- saves: A hosted mission can offer save games, and Project I.G.I. has the start of its own -- off until the whole level is kept
- saves: Project I.G.I.'s world keeps its state -- lifts, doors, switches, pickups, sirens, cameras, what breaks, what turns, and the level's objectives and messages
- saves: Project I.G.I.'s soldiers keep their state, I.G.I. 2's way -- body, health, rounds, where the mind stands and the patrol it was on
- saves: Project I.G.I.'s player keeps its state -- where it stands and looks, its health, what it carries and the rounds in each, and the mission's counts
- saves: Project I.G.I.'s level walk keeps its state -- containers, timers, animations, sounds, cut-scene verdicts and where the vehicles stand -- with the streams of chance, minefield waits and car glass
- saves: Quick save on F5 and quick load on F9 for both titles, and a mission that cannot be played on from is not saved
- saves: Project I.G.I.'s save games are on -- checked in the game and on all fourteen missions
- saves: Project I.G.I. keeps the mines it has laid and the grenades whose fuses are running
- saves: The quick save and quick load keys are bindings of the profile, F5 and F9 until the player chooses others
- saves: A mission is saved from the player's computer, as I.G.I. 2 saves, and no longer from the pause menu
- igi1-saves: A save is read onto the level that is up, as I.G.I. 2 loads, and the mission is no longer brought up again
- computer: The remastered computer is a satellite feed in the heads-up display's own look, with the original's sounds
- touch: A touch screen's layout is the player's to arrange, over three saved layouts, and its buttons are drawn from baked icons
- master: The master server runs self-hosted, on workerd behind Caddy, beside its Workers deployment
- tasks: Typed task events sent through the tree's own walk, task references that empty on delete, and the engine's task list
- igi2: Generators run -- one power rule for both titles' Generator task
- igi1: Project I.G.I.'s content can be read from its install for its soldiers in another game's level
- igi2: Another game's soldiers can stand in an I.G.I. 2 level
- igi1: Project I.G.I.'s soldiers can run in another game's level
- igi1: The soldiers of a hosted level are drawn by the game's own renderer
- igi2: Another game's player can stand for I.G.I. 2's
- igi1: Project I.G.I.'s player can stand for another game's player
- modding: An I.G.I. 2 mission loads headless for a mod's tests, its level brought up as the game's
- igi1: Project I.G.I.'s guards and player stand in I.G.I. 2's levels, drawn and heard as the game's own
- igi1: The guest's guards and player are heard, textured and drawn as the game's own, its player dies to a death camera
- igi2: Radios chatter, on the rule both games share
- igi2: Rotating objects turn, on the rule both games share
- touch: The fire button shows a bullet
- menu: The multiplayer page reads by colour, shows the map, and keeps its place
- menu: The server list shows skeleton rows while it loads, and a server that doesn't answer can't be joined
- console: Death_test kills the player, and campos names the sector
Fixes
- igi2: A fence panel turns by its heading, the one angle it carries, where every panel had faced down the world's X axis and a run along Y stood across itself
- igi2: What a conditional container holds leaves the world when it stops, neither drawn nor met, so mission 4's cutscene helicopter no longer stands beside the one that flies off; a part that turns keeps turning on an object that moves, and a moved prop carries its figures, smoke, sounds and props with it and stands still once it stops
- igi2: A terrain tile draws none of the ground a finer tile inside it draws, and the two meet along one line -- the coarser tile's own samples round the finer one at their true heights, the finer tile's edge held to the straight lines between -- where a sample of overlap showed as a pale square on mission 4's far hillside
- master: A joiner's signalling is held to a rate and an address to so many joins a room and parties a minute, the host's own socket to none; a party member the leader removed is kept out by its address too, and a party's token is read from a header as well as the address asked
- mp: Netcode audit -- a bare acknowledgement no longer stands for the last packet's reliable messages; events reach every client once, sent until acknowledged; a view tick is counted from the newest snapshot held; a snapshot too large for its packets goes whole by the reliable channel (protocol 21)
- igi2-saves: Mines are kept and made again by a load, generic pickups are written against their parents, and a body's flags and the state before its own come back as saved
- igi2-saves: A load takes the messages off the screen and empties the computer's log first, as Game_LoadFromSlot does
- igi2-saves: A mounted gun keeps its weapon, written against it as retail writes StationaryGun/WeaponHandler
- computer: The original computer's pointer no longer sticks when the hidden desktop pointer reaches the edge of the screen
- saves: No save game is made, read, listed or carried over in a multiplayer session
- igi1-saves: A siren raised after a save stops as that save is loaded
- ui: Small text is drawn from an atlas of its own size, and the menus are drawn no smaller than they can be read
- igi1: A StatusMessage runs no child, as the original's handler does not (0x485890)
- sdk: The mod test fixture registers the level's task classes, as the game's content does
- igi1: An ExplodeObject, and the types built on one, run their update where the level's walk reaches them (0x481970)
- igi1: A Radio runs its update where the level's walk reaches it, after its ExplodeObject's (0x43AF90)
- igi1: A Smoke adds its particles where the level's walk reaches it, before they are stepped (0x437DB0)
- igi1: The title player's look between ticks is handed over as axes in columns, as the presenter reads it
- igi1: On the title path the eye and the arms are drawn from the look gathered since the last tick
- host: A title's player is steered by a script's input, and held still under a menu that does not pause
- core: The log file's writer thread outlives a close that did not wait for it
- tests: The three tests that were red are green
- host: The world's effects draw from the played mission's stream
- igi1: What the player threw and fired runs where the level's Dynamic tasks run, after its objects
- igi1: A Siren is an ExplodeObject -- its damage, its blast and isExploded are that object's
- igi1: What the original does in a task's own run is done there, not in a pass after the walk
- igi1: A round is marched by its gun's GunShot task, and what the level makes while it runs runs at Dynamic's tail
- mp: A fallen player holds no gun, and a climbing one is hit where it is drawn
- mp: A dedicated server opens a new room when its room is gone
- igi1: A dead player still stands in its areas
- igi1: The death camera tests its body points 716.8 out, as 0x483A00 does
- igi1: The player's corpse keeps its height where no ground is found, as a soldier's does
- menu: The main menu keeps the cursor free over a level that was left
- igi1: A soldier's sight line is hidden by anything solid wherever it stands, a door at the target included
- tests: A dead player still counts in its areas, and vehicle arming reads its tasks by class
Changes
- saves: The slots, the rules and a mission's save games are shared -- I.G.I. 2 keeps only its load list, its carry-overs and its computer's labels
- saves: The tasks' own save states are an object a context makes, not a static instance
- flow: EditVariable is one task class for both titles, run by the level's own run
- flow: LevelTimer is one task class for both titles
- flow: AreaActivate is one task class, counting by criteria its level's humans and vehicles register
- flow: LevelFlow is one task class, run where the level's walk reaches it
- flow: DefineComputerObjective runs itself, on a handler both titles share
- flow: Project I.G.I.'s StatusMessage is a task that runs itself; the screen's list only shows it
- ambience: Project I.G.I.'s AmbientArea is a task that runs itself
- tasks: A type's behaviour can be its task's before its parameters are a class's; AlarmControl runs itself
- objects: Doors, cameras, rotating objects, pickups and the things worked by hand run from their own tasks
- cutscenes: The vehicles, animations, sounds and scenes a level's story runs are tasks that run themselves
- tasks: Humans, guard generators and lifts run from their own tasks; nothing binds work to a task's node
- level: The level's run has no table of work bound to tasks
- tasks: Static and Idle have classes of their own, and a level's run tells its containers by class, not by name
- objects: MineField is one task class, run where the level's walk reaches it
- render: The world renderer asks the title's objects through one contract, and names no door, lift, camera or cut-scene
- host: The host ends a mission, sounds its vehicles and forces a test outro without naming the cut-scene or objective runtimes
- mission: The shared mission state holds no IGI1 runtime; the host reads its cut-scenes, objectives and objects through contracts
- objects: Each interaction type is a task class that orders its own run
- objects: Door, rotating-object, lift and camera tasks hold the object they are; no registry searches for a task's state each tick
- objects: Each interaction task runs its own type's update by name
- vehicles: A level's vehicles are their own module, and their tasks run through it, not through the cut-scenes
- vehicles: The vehicle classes are named for what they are, not for the cut-scenes
- level: The transforms of the tasks a level moves are the level's, not the cut-scenes'
- vehicles: A CarAI task holds the car and route it drives
- level: One expression runtime for a level -- what is built for it compiles and evaluates through the level's, not one of its own
- hosting: The shared hosting contract asks only what the host calls
- hosting: The level build context names no title's runtime; a title's systems keep what they hand one another by type
- objects: A door's parameters are members of its task class, which the door registry reads
- objects: A lift's parameters are members of its task class, which the lift registry reads
- objects: The parameters of a rotating object, a camera, a camera control and a generator are members of their task classes
- level: The soldiers' guard generators and alarm controls and the computer's highlights evaluate through the level's expressions
- objects: The parameters of the things worked by hand are members of their task classes
- objects: The parameters of an AnimTask, a ConditionalSound, a CarAI and a mounted-gun holder are members of their task classes
- cutscenes: An AnimTask and a ConditionalSound hold what they play; the cut-scene runtime no longer looks a task up to run it
- cutscenes: A CutScene task holds the scene it plays
- vehicles: A car and a helicopter are one kind of task with its own members: the fire gate, the view cone, the door
- igi1: An alarm control's three expressions are members of its task class, and only a task of that class is one
- igi1: The soldiers are stood by their simulation, and the renderer only draws them
- igi1: The soldiers are armed and their tick closed by their simulation
- ai: One guard's orders and script for both games
- igi1: The player's rig is made, tuned and armed whichever level it stands in
- Guest levels and title players share their ids, hooks and Smooth Motion look
- igi1: The player can be ticked and turned from a title path's input
- igi1: The player's life is its own, not the mission's
- igi1: The player is hurt and dies as itself, in whatever surrounds it
- igi1: The player's rounds meet the level's bodies through one shot, wherever it stands
- igi1: One set of rules hurts every player -- the mission's own, a co-op partner and the game's player in another game's level
- host: Project I.G.I.'s mission can stand its player on the title path, and the host's player reads go through it
- host: The computer, the ladder orbit, the rockets' trails and the cheat's hand read the mission, not the hosted player
- igi1: GenericPickup, AlarmLight, Siren, Plane and Train have task classes
- host: Project I.G.I.'s missions stand their player on the title path, and the host loses IHostedPlayer
- hosting: A hosted mission is what makes its level's player
- hosting: Each game is played on its own mission, and Project I.G.I.'s is no longer made for another game
- host: The host holds one thing for the game being played, its mission
- level: A level's run is always the level's own
- igi1: One flag says the level's objects update in its walk
- engine: The count of placement claims is the task tree's, not the process's
- igi1: The map computer's gate and its highlights read the level's own expressions
- igi1: The vehicles' sounds tell a car, a helicopter, a plane and a train by class
- igi1: A soldier's task holds the bodies it runs, and the walk reaches the level's runtime tasks at Dynamic
- igi1: A human's run handler runs its children, and the child that drives it runs its update
- igi1: A soldier's Gun is a task that runs its weapon's clock, ahead of the soldier's update
- igi1: The first game's runtimes live in its own project, and the level has one path
- Vehicle arming has a class of its own, and unused usings are gone
- Dead code, redundant operators and self-modifying loops are gone
Contained
- One way to call code the engine does not own, its failure logged; GameEvents uses it
- One way to call code the engine does not own, its failure logged; GameEvents uses it
- One way to call code the engine does not own, its failure logged; GameEvents uses it
merge
- Project I.G.I.'s soldiers can run in another game's level, on the retail-shaped task model
- Project I.G.I.'s player can stand in another game's level, beside co-op's players
- Project I.G.I.'s mission can stand its player on the title path, behind g_mission_title_player
- Project I.G.I.'s missions stand their player on the title path, and the host loses IHostedPlayer
Downloads
The easiest way to play is the OpenIGI Launcher (openigi.com or its releases), which installs this build for you once its update channel is set to Beta. To run the game yourself, each build comes in two flavours: self-contained runs on any machine, and .NET is a fraction of the size but needs the .NET 10 runtime installed.
| Self-contained | Needs .NET 10 | |
|---|---|---|
| Windows | openigi-game-0.6.8-beta.1-win-x64.exe | openigi-game-0.6.8-beta.1-win-x64-dotnet.exe |
| Linux | openigi-game-0.6.8-beta.1-linux-x64 | openigi-game-0.6.8-beta.1-linux-x64-dotnet |
| macOS (Apple silicon) | openigi-game-0.6.8-beta.1-osx-arm64.tar.gz | openigi-game-0.6.8-beta.1-osx-arm64-dotnet.tar.gz |
Windows and Linux builds are a single executable (on Linux, chmod +x it first). macOS builds are an app in a tarball.
On macOS and Linux, the launcher installs with one command: curl -fsSL https://openigi.com/install.sh | bash.
The macOS builds are not notarized, so macOS reports an app downloaded with a browser as "damaged"; clear that with xattr -dr com.apple.quarantine "/Applications/OpenIGI Launcher.app" (or the app's path).
OpenIGI needs your own copy of Project I.G.I.; it ships none of the game's data. Verify a download with sha256sum -c SHA256SUMS.
Dedicated server: openigi-server-0.6.8-beta.1-linux-x64.tar.gz (sudo ./install.sh) or openigi-server-0.6.8-beta.1-win-x64.zip (.\install.ps1); it plays your own copy of the game too.
On ARM hosts: openigi-server-0.6.8-beta.1-linux-arm64.tar.gz or openigi-server-0.6.8-beta.1-win-arm64.zip, installed the same way.
0.6.7
Full changelog
New
- blast: The bomb brings buildings down in slabs that settle into a rubble mound under a collapse cloud, and the fireball costs a third of what it did; bomb_blast_skip fast-forwards a blast
- mp: Mission 3's arena layout updated
- mp: The money is server settings (mp_moneystart, mp_moneycap, mp_moneykill, mp_moneyteamkill, mp_moneywin, mp_moneylose, mp_moneyplant), what a player earns or loses shows beside its money, a fine stops at nothing, and a buy plays the gun pickup sound
Fixes
- desktop: A clipboard the window system cannot read or write no longer crashes the game
- mp: A bomb's danger is shown from the moment it is planted, and a round the bomb ended holds its result twenty seconds
- mp: A versus match lays none of the level's medipacks, ammunition or guns, on the server and every player, nor brings them back with a new round
- mp: A versus arena takes out the mission's story -- its scripted helicopters, cars, trains and planes, manned guns, timers, one-off sounds and messages
- mp: A switch a joined player presses clicks once on its game, not again when the server's word of the same press comes back
Downloads
The easiest way to play is the OpenIGI Launcher (openigi.com or its releases), which installs this build for you. To run the game yourself, each build comes in two flavours: self-contained runs on any machine, and .NET is a fraction of the size but needs the .NET 10 runtime installed.
| Self-contained | Needs .NET 10 | |
|---|---|---|
| Windows | openigi-game-0.6.7-win-x64.exe | openigi-game-0.6.7-win-x64-dotnet.exe |
| Linux | openigi-game-0.6.7-linux-x64 | openigi-game-0.6.7-linux-x64-dotnet |
| macOS (Apple silicon) | openigi-game-0.6.7-osx-arm64.tar.gz | openigi-game-0.6.7-osx-arm64-dotnet.tar.gz |
Windows and Linux builds are a single executable (on Linux, chmod +x it first). macOS builds are an app in a tarball.
On macOS and Linux, the launcher installs with one command: curl -fsSL https://openigi.com/install.sh | bash.
The macOS builds are not notarized, so macOS reports an app downloaded with a browser as "damaged"; clear that with xattr -dr com.apple.quarantine "/Applications/OpenIGI Launcher.app" (or the app's path).
OpenIGI needs your own copy of Project I.G.I.; it ships none of the game's data. Verify a download with sha256sum -c SHA256SUMS.
Dedicated server: openigi-server-0.6.7-linux-x64.tar.gz (sudo ./install.sh) or openigi-server-0.6.7-win-x64.zip (.\install.ps1); it plays your own copy of the game too.
On ARM hosts: openigi-server-0.6.7-linux-arm64.tar.gz or openigi-server-0.6.7-win-arm64.zip, installed the same way.
0.6.7-beta.1
Full changelog
New
- sd: The bomb goes off with a blast to match: props shatter, walls breach, nearby buildings come down, a fireball and shockwave light the base and the camera shakes; its damage carries round corners and the HUD warns how much would reach you
- mp: The buy time is a server setting, mp_buytime, set in server.cfg or at the server console and taken as each round begins
- blast: The bomb brings buildings down in slabs that settle into a rubble mound under a collapse cloud, and the fireball costs a third of what it did; bomb_blast_skip fast-forwards a blast
- mp: Mission 3's arena layout updated
- mp: The money is server settings (mp_moneystart, mp_moneycap, mp_moneykill, mp_moneyteamkill, mp_moneywin, mp_moneylose, mp_moneyplant), what a player earns or loses shows beside its money, a fine stops at nothing, and a buy plays the gun pickup sound
Fixes
- release: Libdatachannel downloads retry through GitHub's 504s instead of failing the release
- release: Libdatachannel comes through the GitHub API when the release download address keeps answering 504
- mp: A player can switch to a side whose players dropped, and a newcomer joins the side that is short of players
- browser: Closed rooms leave the server browser instead of standing there for good as Mission 0, 0/0, saved or recent ones too
- mp: A player climbing a ladder when the round ends starts the next round at its spawn, not back on the ladder
- mp: The server holds the weapon each player chose, so the bomb carrier plants with the bomb in hand; switches no longer drift apart when the two copies' weapons differ
- mp: The pause menu no longer stops a multiplayer game; the match plays on for everyone and only the player at the menu lets go of the controls
- mp: A gate shut on a player standing in it goes back open on the server as on the player's game, instead of opening and shutting for good with its sound looping
- mp: A player killed for leaving the bounds falls on its own game too, instead of playing on there while the server holds it dead
- desktop: A clipboard the window system cannot read or write no longer crashes the game
- mp: A bomb's danger is shown from the moment it is planted, and a round the bomb ended holds its result twenty seconds
- mp: A versus match lays none of the level's medipacks, ammunition or guns, on the server and every player, nor brings them back with a new round
- mp: A versus arena takes out the mission's story -- its scripted helicopters, cars, trains and planes, manned guns, timers, one-off sounds and messages
- mp: A switch a joined player presses clicks once on its game, not again when the server's word of the same press comes back
Downloads
The easiest way to play is the OpenIGI Launcher (openigi.com or its releases), which installs this build for you once its update channel is set to Beta. To run the game yourself, each build comes in two flavours: self-contained runs on any machine, and .NET is a fraction of the size but needs the .NET 10 runtime installed.
| Self-contained | Needs .NET 10 | |
|---|---|---|
| Windows | openigi-game-0.6.7-beta.1-win-x64.exe | openigi-game-0.6.7-beta.1-win-x64-dotnet.exe |
| Linux | openigi-game-0.6.7-beta.1-linux-x64 | openigi-game-0.6.7-beta.1-linux-x64-dotnet |
| macOS (Apple silicon) | openigi-game-0.6.7-beta.1-osx-arm64.tar.gz | openigi-game-0.6.7-beta.1-osx-arm64-dotnet.tar.gz |
Windows and Linux builds are a single executable (on Linux, chmod +x it first). macOS builds are an app in a tarball.
On macOS and Linux, the launcher installs with one command: curl -fsSL https://openigi.com/install.sh | bash.
The macOS builds are not notarized, so macOS reports an app downloaded with a browser as "damaged"; clear that with xattr -dr com.apple.quarantine "/Applications/OpenIGI Launcher.app" (or the app's path).
OpenIGI needs your own copy of Project I.G.I.; it ships none of the game's data. Verify a download with sha256sum -c SHA256SUMS.
Dedicated server: openigi-server-0.6.7-beta.1-linux-x64.tar.gz (sudo ./install.sh) or openigi-server-0.6.7-beta.1-win-x64.zip (.\install.ps1); it plays your own copy of the game too.
On ARM hosts: openigi-server-0.6.7-beta.1-linux-arm64.tar.gz or openigi-server-0.6.7-beta.1-win-arm64.zip, installed the same way.
0.6.6
Full changelog
New
- mp: The buy time is a server setting, mp_buytime, set in server.cfg or at the server console and taken as each round begins
Fixes
- browser: Closed rooms leave the server browser instead of standing there for good as Mission 0, 0/0, saved or recent ones too
- mp: A player climbing a ladder when the round ends starts the next round at its spawn, not back on the ladder
- mp: The server holds the weapon each player chose, so the bomb carrier plants with the bomb in hand; switches no longer drift apart when the two copies' weapons differ
- mp: The pause menu no longer stops a multiplayer game; the match plays on for everyone and only the player at the menu lets go of the controls
- mp: A gate shut on a player standing in it goes back open on the server as on the player's game, instead of opening and shutting for good with its sound looping
- mp: A player killed for leaving the bounds falls on its own game too, instead of playing on there while the server holds it dead
Downloads
The easiest way to play is the OpenIGI Launcher (openigi.com or its releases), which installs this build for you. To run the game yourself, each build comes in two flavours: self-contained runs on any machine, and .NET is a fraction of the size but needs the .NET 10 runtime installed.
| Self-contained | Needs .NET 10 | |
|---|---|---|
| Windows | openigi-game-0.6.6-win-x64.exe | openigi-game-0.6.6-win-x64-dotnet.exe |
| Linux | openigi-game-0.6.6-linux-x64 | openigi-game-0.6.6-linux-x64-dotnet |
| macOS (Apple silicon) | openigi-game-0.6.6-osx-arm64.tar.gz | openigi-game-0.6.6-osx-arm64-dotnet.tar.gz |
Windows and Linux builds are a single executable (on Linux, chmod +x it first). macOS builds are an app in a tarball.
On macOS and Linux, the launcher installs with one command: curl -fsSL https://openigi.com/install.sh | bash.
The macOS builds are not notarized, so macOS reports an app downloaded with a browser as "damaged"; clear that with xattr -dr com.apple.quarantine "/Applications/OpenIGI Launcher.app" (or the app's path).
OpenIGI needs your own copy of Project I.G.I.; it ships none of the game's data. Verify a download with sha256sum -c SHA256SUMS.
Dedicated server: openigi-server-0.6.6-linux-x64.tar.gz (sudo ./install.sh) or openigi-server-0.6.6-win-x64.zip (.\install.ps1); it plays your own copy of the game too.
0.6.5
Full changelog
New
- sd: The bomb goes off with a blast to match: props shatter, walls breach, nearby buildings come down, a fireball and shockwave light the base and the camera shakes; its damage carries round corners and the HUD warns how much would reach you
Fixes
- mp: A player can switch to a side whose players dropped, and a newcomer joins the side that is short of players
Downloads
The easiest way to play is the OpenIGI Launcher (openigi.com or its releases), which installs this build for you. To run the game yourself, each build comes in two flavours: self-contained runs on any machine, and .NET is a fraction of the size but needs the .NET 10 runtime installed.
| Self-contained | Needs .NET 10 | |
|---|---|---|
| Windows | openigi-game-0.6.5-win-x64.exe | openigi-game-0.6.5-win-x64-dotnet.exe |
| Linux | openigi-game-0.6.5-linux-x64 | openigi-game-0.6.5-linux-x64-dotnet |
| macOS (Apple silicon) | openigi-game-0.6.5-osx-arm64.tar.gz | openigi-game-0.6.5-osx-arm64-dotnet.tar.gz |
Windows and Linux builds are a single executable (on Linux, chmod +x it first). macOS builds are an app in a tarball.
On macOS and Linux, the launcher installs with one command: curl -fsSL https://openigi.com/install.sh | bash.
The macOS builds are not notarized, so macOS reports an app downloaded with a browser as "damaged"; clear that with xattr -dr com.apple.quarantine "/Applications/OpenIGI Launcher.app" (or the app's path).
OpenIGI needs your own copy of Project I.G.I.; it ships none of the game's data. Verify a download with sha256sum -c SHA256SUMS.
Dedicated server: openigi-server-0.6.5-linux-x64.tar.gz (sudo ./install.sh) or openigi-server-0.6.5-win-x64.zip (.\install.ps1); it plays your own copy of the game too.
0.6.4
Full changelog
Fixes
- render: Models are culled by their stored winding, so ladders, doors and the watchtower keep their outsides on Ultra (#50)
- webgpu: The WebGPU renderer starts on macOS, falls back to Vulkan when it cannot, and no longer dies at the first window (#17)
- release: Libdatachannel downloads retry through GitHub's 504s instead of failing the release
- release: Libdatachannel comes through the GitHub API when the release download address keeps answering 504
Demos
- A joined session recorded from its start, saved with demo_save, played with -playdemo
Elimination
- Rounds of one life
Master
- The server list kept in storage, and a room claimed only from the address that hosts it
- A room waits for its host only when the host says it comes back
Parties
- Friends follow their leader to every server and room
S&D
- A player who died starts the next round with the spawn kit; survivors keep what they carry
Downloads
The easiest way to play is the OpenIGI Launcher (openigi.com or its releases), which installs this build for you. To run the game yourself, each build comes in two flavours: self-contained runs on any machine, and .NET is a fraction of the size but needs the .NET 10 runtime installed.
| Self-contained | Needs .NET 10 | |
|---|---|---|
| Windows | openigi-game-0.6.4-win-x64.exe | openigi-game-0.6.4-win-x64-dotnet.exe |
| Linux | openigi-game-0.6.4-linux-x64 | openigi-game-0.6.4-linux-x64-dotnet |
| macOS (Apple silicon) | openigi-game-0.6.4-osx-arm64.tar.gz | openigi-game-0.6.4-osx-arm64-dotnet.tar.gz |
Windows and Linux builds are a single executable (on Linux, chmod +x it first). macOS builds are an app in a tarball.
On macOS and Linux, the launcher installs with one command: curl -fsSL https://openigi.com/install.sh | bash.
The macOS builds are not notarized, so macOS reports an app downloaded with a browser as "damaged"; clear that with xattr -dr com.apple.quarantine "/Applications/OpenIGI Launcher.app" (or the app's path).
OpenIGI needs your own copy of Project I.G.I.; it ships none of the game's data. Verify a download with sha256sum -c SHA256SUMS.
Dedicated server: openigi-server-0.6.4-linux-x64.tar.gz (sudo ./install.sh) or openigi-server-0.6.4-win-x64.zip (.\install.ps1); it plays your own copy of the game too.
0.6.4-beta.8
Full changelog
Maintenance release: no player-facing changes since v0.6.4-beta.7.
Downloads
The easiest way to play is the OpenIGI Launcher (openigi.com or its releases), which installs this build for you once its update channel is set to Beta. To run the game yourself, each build comes in two flavours: self-contained runs on any machine, and .NET is a fraction of the size but needs the .NET 10 runtime installed.
| Self-contained | Needs .NET 10 | |
|---|---|---|
| Windows | openigi-game-0.6.4-beta.8-win-x64.exe | openigi-game-0.6.4-beta.8-win-x64-dotnet.exe |
| Linux | openigi-game-0.6.4-beta.8-linux-x64 | openigi-game-0.6.4-beta.8-linux-x64-dotnet |
| macOS (Apple silicon) | openigi-game-0.6.4-beta.8-osx-arm64.tar.gz | openigi-game-0.6.4-beta.8-osx-arm64-dotnet.tar.gz |
Windows and Linux builds are a single executable (on Linux, chmod +x it first). macOS builds are an app in a tarball.
On macOS and Linux, the launcher installs with one command: curl -fsSL https://openigi.com/install.sh | bash.
The macOS builds are not notarized, so macOS reports an app downloaded with a browser as "damaged"; clear that with xattr -dr com.apple.quarantine "/Applications/OpenIGI Launcher.app" (or the app's path).
OpenIGI needs your own copy of Project I.G.I.; it ships none of the game's data. Verify a download with sha256sum -c SHA256SUMS.
Dedicated server: openigi-server-0.6.4-beta.8-linux-x64.tar.gz (sudo ./install.sh) or openigi-server-0.6.4-beta.8-win-x64.zip (.\install.ps1); it plays your own copy of the game too.
0.6.4-beta.7
Full changelog
Maintenance release: no player-facing changes since v0.6.4-beta.6.
Downloads
The easiest way to play is the OpenIGI Launcher (openigi.com or its releases), which installs this build for you once its update channel is set to Beta. To run the game yourself, each build comes in two flavours: self-contained runs on any machine, and .NET is a fraction of the size but needs the .NET 10 runtime installed.
| Self-contained | Needs .NET 10 | |
|---|---|---|
| Windows | openigi-game-0.6.4-beta.7-win-x64.exe | openigi-game-0.6.4-beta.7-win-x64-dotnet.exe |
| Linux | openigi-game-0.6.4-beta.7-linux-x64 | openigi-game-0.6.4-beta.7-linux-x64-dotnet |
| macOS (Apple silicon) | openigi-game-0.6.4-beta.7-osx-arm64.tar.gz | openigi-game-0.6.4-beta.7-osx-arm64-dotnet.tar.gz |
Windows and Linux builds are a single executable (on Linux, chmod +x it first). macOS builds are an app in a tarball.
On macOS and Linux, the launcher installs with one command: curl -fsSL https://openigi.com/install.sh | bash.
The macOS builds are not notarized, so macOS reports an app downloaded with a browser as "damaged"; clear that with xattr -dr com.apple.quarantine "/Applications/OpenIGI Launcher.app" (or the app's path).
OpenIGI needs your own copy of Project I.G.I.; it ships none of the game's data. Verify a download with sha256sum -c SHA256SUMS.
Dedicated server: openigi-server-0.6.4-beta.7-linux-x64.tar.gz (sudo ./install.sh) or openigi-server-0.6.4-beta.7-win-x64.zip (.\install.ps1); it plays your own copy of the game too.
0.6.4-beta.6
Full changelog
Maintenance release: no player-facing changes since v0.6.4-beta.5.
Downloads
The easiest way to play is the OpenIGI Launcher (openigi.com or its releases), which installs this build for you once its update channel is set to Beta. To run the game yourself, each build comes in two flavours: self-contained runs on any machine, and .NET is a fraction of the size but needs the .NET 10 runtime installed.
| Self-contained | Needs .NET 10 | |
|---|---|---|
| Windows | openigi-game-0.6.4-beta.6-win-x64.exe | openigi-game-0.6.4-beta.6-win-x64-dotnet.exe |
| Linux | openigi-game-0.6.4-beta.6-linux-x64 | openigi-game-0.6.4-beta.6-linux-x64-dotnet |
| macOS (Apple silicon) | openigi-game-0.6.4-beta.6-osx-arm64.tar.gz | openigi-game-0.6.4-beta.6-osx-arm64-dotnet.tar.gz |
Windows and Linux builds are a single executable (on Linux, chmod +x it first). macOS builds are an app in a tarball.
On macOS and Linux, the launcher installs with one command: curl -fsSL https://openigi.com/install.sh | bash.
The macOS builds are not notarized, so macOS reports an app downloaded with a browser as "damaged"; clear that with xattr -dr com.apple.quarantine "/Applications/OpenIGI Launcher.app" (or the app's path).
OpenIGI needs your own copy of Project I.G.I.; it ships none of the game's data. Verify a download with sha256sum -c SHA256SUMS.
Dedicated server: openigi-server-0.6.4-beta.6-linux-x64.tar.gz (sudo ./install.sh) or openigi-server-0.6.4-beta.6-win-x64.zip (.\install.ps1); it plays your own copy of the game too.
0.6.4-beta.5
Full changelog
Maintenance release: no player-facing changes since v0.6.4-beta.4.
Downloads
The easiest way to play is the OpenIGI Launcher (openigi.com or its releases), which installs this build for you once its update channel is set to Beta. To run the game yourself, each build comes in two flavours: self-contained runs on any machine, and .NET is a fraction of the size but needs the .NET 10 runtime installed.
| Self-contained | Needs .NET 10 | |
|---|---|---|
| Windows | openigi-game-0.6.4-beta.5-win-x64.exe | openigi-game-0.6.4-beta.5-win-x64-dotnet.exe |
| Linux | openigi-game-0.6.4-beta.5-linux-x64 | openigi-game-0.6.4-beta.5-linux-x64-dotnet |
| macOS (Apple silicon) | openigi-game-0.6.4-beta.5-osx-arm64.tar.gz | openigi-game-0.6.4-beta.5-osx-arm64-dotnet.tar.gz |
Windows and Linux builds are a single executable (on Linux, chmod +x it first). macOS builds are an app in a tarball.
On macOS and Linux, the launcher installs with one command: curl -fsSL https://openigi.com/install.sh | bash.
The macOS builds are not notarized, so macOS reports an app downloaded with a browser as "damaged"; clear that with xattr -dr com.apple.quarantine "/Applications/OpenIGI Launcher.app" (or the app's path).
OpenIGI needs your own copy of Project I.G.I.; it ships none of the game's data. Verify a download with sha256sum -c SHA256SUMS.
Dedicated server: openigi-server-0.6.4-beta.5-linux-x64.tar.gz (sudo ./install.sh) or openigi-server-0.6.4-beta.5-win-x64.zip (.\install.ps1); it plays your own copy of the game too.
0.6.4-beta.4
Full changelog
Maintenance release: no player-facing changes since v0.6.4-beta.3.
Downloads
The easiest way to play is the OpenIGI Launcher (openigi.com or its releases), which installs this build for you once its update channel is set to Beta. To run the game yourself, each build comes in two flavours: self-contained runs on any machine, and .NET is a fraction of the size but needs the .NET 10 runtime installed.
| Self-contained | Needs .NET 10 | |
|---|---|---|
| Windows | openigi-game-0.6.4-beta.4-win-x64.exe | openigi-game-0.6.4-beta.4-win-x64-dotnet.exe |
| Linux | openigi-game-0.6.4-beta.4-linux-x64 | openigi-game-0.6.4-beta.4-linux-x64-dotnet |
| macOS (Apple silicon) | openigi-game-0.6.4-beta.4-osx-arm64.tar.gz | openigi-game-0.6.4-beta.4-osx-arm64-dotnet.tar.gz |
Windows and Linux builds are a single executable (on Linux, chmod +x it first). macOS builds are an app in a tarball.
On macOS and Linux, the launcher installs with one command: curl -fsSL https://openigi.com/install.sh | bash.
The macOS builds are not notarized, so macOS reports an app downloaded with a browser as "damaged"; clear that with xattr -dr com.apple.quarantine "/Applications/OpenIGI Launcher.app" (or the app's path).
OpenIGI needs your own copy of Project I.G.I.; it ships none of the game's data. Verify a download with sha256sum -c SHA256SUMS.
Dedicated server: openigi-server-0.6.4-beta.4-linux-x64.tar.gz (sudo ./install.sh) or openigi-server-0.6.4-beta.4-win-x64.zip (.\install.ps1); it plays your own copy of the game too.
0.6.3
Full changelog
New
- view: A widescreen sees more at the sides instead of a cropped picture, and the original HUD's size is a setting
- lighting: A level with no outdoors keeps a tenth of its shipped lightmaps under the dynamic light
- render: Each mission owns its look, its night and its rain
Fixes
- render: A room the portal walk did not reach still casts shadows, so the lighting no longer flips as the head turns
- lighting: A level with no ground, like the last mission, is lit without a sun
- render: A tunnel inside a chamber's bound keeps the eye, as the original's does
- player: Putting the binoculars away closes them at once (#48)
- view: The arms and weapon follow the landing dip with Smooth Motion off (#49)
- formats: Load unpacked LOOP 10 fonts without mission-entry crashes (#36)
- launcher: On Wayland the window is sized in logical units, so it opens inside the screen
Performance
- render: Non-DLSS frames run 25-29% faster on High, every picture byte-identical
- shadows: A lamp keeps its static casters, and a frame redraws only what moves under it
- lamps: A pixel walks only the lamps that can reach its cell of the view
Downloads
The easiest way to play is the OpenIGI Launcher (openigi.com or its releases), which installs this build for you. To run the game yourself, each build comes in two flavours: self-contained runs on any machine, and .NET is a fraction of the size but needs the .NET 10 runtime installed.
| Self-contained | Needs .NET 10 | |
|---|---|---|
| Windows | openigi-game-0.6.3-win-x64.exe | openigi-game-0.6.3-win-x64-dotnet.exe |
| Linux | openigi-game-0.6.3-linux-x64 | openigi-game-0.6.3-linux-x64-dotnet |
| macOS (Apple silicon) | openigi-game-0.6.3-osx-arm64.tar.gz | openigi-game-0.6.3-osx-arm64-dotnet.tar.gz |
Windows and Linux builds are a single executable (on Linux, chmod +x it first). macOS builds are an app in a tarball.
On macOS and Linux, the launcher installs with one command: curl -fsSL https://openigi.com/install.sh | bash.
The macOS builds are not notarized, so macOS reports an app downloaded with a browser as "damaged"; clear that with xattr -dr com.apple.quarantine "/Applications/OpenIGI Launcher.app" (or the app's path).
OpenIGI needs your own copy of Project I.G.I.; it ships none of the game's data. Verify a download with sha256sum -c SHA256SUMS.
0.6.2
Full changelog
New
- scripting: QSC source for every script, and back to the same bytes
- editor: A mission's object script as an editable document
- editor: History, selection and the mission edits that use them
- ui: The editor kit's desktop input, fields, buttons and menus
- ui: Docking, the tree view and the property grid
- editor: The editor opens inside the game
- editor: Save into a project the game loads from
- shell: An Editor button in the front end
- editor: Moved objects move in the world at once
- editor: Play the mission from the editor
- editor: Duplicate objects
- editor: Read and edit any mission script as QSC
- editor: A content browser with previews
- editor: Rotate objects, live
- editor: Problems, and an export for the retail game
- editor: A model viewer in the content browser
- editor: Hear sounds in the content browser
- formats: Edit AI graph files record by record
- editor: See and move AI graph nodes in the viewport
- editor: Resize trigger and ambient areas in the viewport
- formats: Rebuild AI route tables when graph nodes move
- editor: Sculpt IGI2 terrain, s&box-style viewport, working picks
- editor: S&box polish, IGI1 terrain sculpt, new missions, map analysis
- editor: Typed script vocabulary and mission graph model
- editor: Graph compilers, AI event graphs, action nodes and macros
- editor: Graph editor polish, AI nav graphs, patrols, smart fields
- host: -nosave, and test hosts no longer write the player's profile and settings
- sentries: Mission 14's gun holders watch, turn, fire and change sides
- launcher: The Editor entry opens the editor instead of reading coming soon
Fixes
- editor: What the first runs in the game showed
- editor: No game path in the host's editor contract
- pickups: A taken gun or ammo box leaves the level in its own update, so mission 11 completes
- soldiers: A female soldier runs her RunTo legs, so Anya reaches the bomb in mission 14
- wire: Level wires keep stepping and riders hang on the cable
- coop: A partner at a computer, a lock, a fence or a ladder's top is drawn as its own game draws it
- coop: A joiner's rounds in third person go where its crosshair is on the host's game
- presets: A setting turned back reads as its preset again, so Vanilla's rain returns after Storm Effects is toggled
Performance
- Hash packed-pair keys so IGI2 terrain stops crawling
Changes
- One world-unit constant for both games
- ui: One popup placement for the console and the editor
Downloads
The easiest way to play is the OpenIGI Launcher (openigi.com or its releases), which installs this build for you. To run the game yourself, each build comes in two flavours: self-contained runs on any machine, and .NET is a fraction of the size but needs the .NET 10 runtime installed.
| Self-contained | Needs .NET 10 | |
|---|---|---|
| Windows | openigi-game-0.6.2-win-x64.exe | openigi-game-0.6.2-win-x64-dotnet.exe |
| Linux | openigi-game-0.6.2-linux-x64 | openigi-game-0.6.2-linux-x64-dotnet |
| macOS (Apple silicon) | openigi-game-0.6.2-osx-arm64.tar.gz | openigi-game-0.6.2-osx-arm64-dotnet.tar.gz |
Windows and Linux builds are a single executable (on Linux, chmod +x it first). macOS builds are an app in a tarball.
On macOS and Linux, the launcher installs with one command: curl -fsSL https://openigi.com/install.sh | bash.
The macOS builds are not notarized, so macOS reports an app downloaded with a browser as "damaged"; clear that with xattr -dr com.apple.quarantine "/Applications/OpenIGI Launcher.app" (or the app's path).
OpenIGI needs your own copy of Project I.G.I.; it ships none of the game's data. Verify a download with sha256sum -c SHA256SUMS.
Reply on the forum
A question or a hands-on report? Open the discussion on the forum.