const lab = new Lab241();
git commit -m "ship it"
if (score > best) save(run);
lab.games.launch({ original: true });
def evaluate(model, tasks):
function build(game) {
class Agent(nn.Module):
// measure, then build
for (const q of queries) {
}
return self.policy(x)
export default lab;
}
{ "status": "building" }
import { Lab } from "lab-241";
await lab.research.train(model);
SELECT * FROM ideas WHERE ready;
while (learning) { iterate(); }
metrics.push({ loss, reward });
return [run(t) for t in tasks]
prototype(game).playtest();
def forward(self, x):
try { await ship(); } catch (e) {}
rank(page, q).improve();
npm run build && deploy
const rank = await seo.audit(url);
const lab = new Lab241();
git commit -m "ship it"
if (score > best) save(run);
lab.games.launch({ original: true });
def evaluate(model, tasks):
function build(game) {
class Agent(nn.Module):
// measure, then build
for (const q of queries) {
}
return self.policy(x)
export default lab;
}
{ "status": "building" }
import { Lab } from "lab-241";
await lab.research.train(model);
SELECT * FROM ideas WHERE ready;
while (learning) { iterate(); }const lab = new Lab241();
git commit -m "ship it"
if (score > best) save(run);
lab.games.launch({ original: true });
def evaluate(model, tasks):
function build(game) {
class Agent(nn.Module):
// measure, then build
for (const q of queries) {
}
return self.policy(x)
export default lab;
}
{ "status": "building" }
import { Lab } from "lab-241";
await lab.research.train(model);
SELECT * FROM ideas WHERE ready;
while (learning) { iterate(); }
metrics.push({ loss, reward });
return [run(t) for t in tasks]
prototype(game).playtest();
def forward(self, x):
try { await ship(); } catch (e) {}
rank(page, q).improve();
npm run build && deploy
const rank = await seo.audit(url);
const lab = new Lab241();
git commit -m "ship it"
if (score > best) save(run);
lab.games.launch({ original: true });
def evaluate(model, tasks):
function build(game) {
class Agent(nn.Module):
// measure, then build
for (const q of queries) {
}
return self.policy(x)
export default lab;
}
{ "status": "building" }
import { Lab } from "lab-241";
await lab.research.train(model);
SELECT * FROM ideas WHERE ready;
while (learning) { iterate(); }}
{ "status": "building" }
import { Lab } from "lab-241";
await lab.research.train(model);
SELECT * FROM ideas WHERE ready;
while (learning) { iterate(); }
metrics.push({ loss, reward });
return [run(t) for t in tasks]
prototype(game).playtest();
def forward(self, x):
try { await ship(); } catch (e) {}
rank(page, q).improve();
npm run build && deploy
const rank = await seo.audit(url);
const lab = new Lab241();
git commit -m "ship it"
if (score > best) save(run);
lab.games.launch({ original: true });
def evaluate(model, tasks):
function build(game) {
class Agent(nn.Module):
// measure, then build
for (const q of queries) {
}
return self.policy(x)
export default lab;
}
{ "status": "building" }
import { Lab } from "lab-241";
await lab.research.train(model);
SELECT * FROM ideas WHERE ready;
while (learning) { iterate(); }
metrics.push({ loss, reward });
return [run(t) for t in tasks]
prototype(game).playtest();
def forward(self, x):
try { await ship(); } catch (e) {}
rank(page, q).improve();
npm run build && deploy
const rank = await seo.audit(url);
const lab = new Lab241();
git commit -m "ship it"
if (score > best) save(run);
lab.games.launch({ original: true });}
{ "status": "building" }
import { Lab } from "lab-241";
await lab.research.train(model);
SELECT * FROM ideas WHERE ready;
while (learning) { iterate(); }
metrics.push({ loss, reward });
return [run(t) for t in tasks]
prototype(game).playtest();
def forward(self, x):
try { await ship(); } catch (e) {}
rank(page, q).improve();
npm run build && deploy
const rank = await seo.audit(url);
const lab = new Lab241();
git commit -m "ship it"
if (score > best) save(run);
lab.games.launch({ original: true });
def evaluate(model, tasks):
function build(game) {
class Agent(nn.Module):
// measure, then build
for (const q of queries) {
}
return self.policy(x)
export default lab;
}
{ "status": "building" }
import { Lab } from "lab-241";
await lab.research.train(model);
SELECT * FROM ideas WHERE ready;
while (learning) { iterate(); }
metrics.push({ loss, reward });
return [run(t) for t in tasks]
prototype(game).playtest();
def forward(self, x):
try { await ship(); } catch (e) {}
rank(page, q).improve();
npm run build && deploy
const rank = await seo.audit(url);
const lab = new Lab241();
git commit -m "ship it"
if (score > best) save(run);
lab.games.launch({ original: true });{ "status": "building" }
import { Lab } from "lab-241";
await lab.research.train(model);
SELECT * FROM ideas WHERE ready;
while (learning) { iterate(); }
metrics.push({ loss, reward });
return [run(t) for t in tasks]
prototype(game).playtest();
def forward(self, x):
try { await ship(); } catch (e) {}
rank(page, q).improve();
npm run build && deploy
const rank = await seo.audit(url);
const lab = new Lab241();
git commit -m "ship it"
if (score > best) save(run);
lab.games.launch({ original: true });
def evaluate(model, tasks):
function build(game) {
class Agent(nn.Module):
// measure, then build
for (const q of queries) {
}
return self.policy(x)
export default lab;
}
{ "status": "building" }
import { Lab } from "lab-241";
await lab.research.train(model);
SELECT * FROM ideas WHERE ready;
while (learning) { iterate(); }
metrics.push({ loss, reward });
return [run(t) for t in tasks]
prototype(game).playtest();
def forward(self, x):
try { await ship(); } catch (e) {}
rank(page, q).improve();
npm run build && deploy
const rank = await seo.audit(url);
const lab = new Lab241();
git commit -m "ship it"
if (score > best) save(run);
lab.games.launch({ original: true });
def evaluate(model, tasks):{ "status": "building" }
import { Lab } from "lab-241";
await lab.research.train(model);
SELECT * FROM ideas WHERE ready;
while (learning) { iterate(); }
metrics.push({ loss, reward });
return [run(t) for t in tasks]
prototype(game).playtest();
def forward(self, x):
try { await ship(); } catch (e) {}
rank(page, q).improve();
npm run build && deploy
const rank = await seo.audit(url);
const lab = new Lab241();
git commit -m "ship it"
if (score > best) save(run);
lab.games.launch({ original: true });
def evaluate(model, tasks):
function build(game) {
class Agent(nn.Module):
// measure, then build
for (const q of queries) {
}
return self.policy(x)
export default lab;
}
{ "status": "building" }
import { Lab } from "lab-241";
await lab.research.train(model);
SELECT * FROM ideas WHERE ready;
while (learning) { iterate(); }
metrics.push({ loss, reward });
return [run(t) for t in tasks]
prototype(game).playtest();
def forward(self, x):
try { await ship(); } catch (e) {}
rank(page, q).improve();
npm run build && deploy
const rank = await seo.audit(url);
const lab = new Lab241();
git commit -m "ship it"
if (score > best) save(run);
lab.games.launch({ original: true });
def evaluate(model, tasks):}
{ "status": "building" }
import { Lab } from "lab-241";
await lab.research.train(model);
SELECT * FROM ideas WHERE ready;
while (learning) { iterate(); }
metrics.push({ loss, reward });
return [run(t) for t in tasks]
prototype(game).playtest();
def forward(self, x):
try { await ship(); } catch (e) {}
rank(page, q).improve();
npm run build && deploy
const rank = await seo.audit(url);
const lab = new Lab241();
git commit -m "ship it"
if (score > best) save(run);
lab.games.launch({ original: true });
def evaluate(model, tasks):
function build(game) {
class Agent(nn.Module):
// measure, then build
for (const q of queries) {
}
return self.policy(x)
export default lab;
}
{ "status": "building" }
import { Lab } from "lab-241";
await lab.research.train(model);
SELECT * FROM ideas WHERE ready;
while (learning) { iterate(); }
metrics.push({ loss, reward });
return [run(t) for t in tasks]
prototype(game).playtest();
def forward(self, x):
try { await ship(); } catch (e) {}
rank(page, q).improve();
npm run build && deploy
const rank = await seo.audit(url);
const lab = new Lab241();
git commit -m "ship it"
if (score > best) save(run);
lab.games.launch({ original: true });}
{ "status": "building" }
import { Lab } from "lab-241";
await lab.research.train(model);
SELECT * FROM ideas WHERE ready;
while (learning) { iterate(); }
metrics.push({ loss, reward });
return [run(t) for t in tasks]
prototype(game).playtest();
def forward(self, x):
try { await ship(); } catch (e) {}
rank(page, q).improve();
npm run build && deploy
const rank = await seo.audit(url);
const lab = new Lab241();
git commit -m "ship it"
if (score > best) save(run);
lab.games.launch({ original: true });
def evaluate(model, tasks):
function build(game) {
class Agent(nn.Module):
// measure, then build
for (const q of queries) {
}
return self.policy(x)
export default lab;
}
{ "status": "building" }
import { Lab } from "lab-241";
await lab.research.train(model);
SELECT * FROM ideas WHERE ready;
while (learning) { iterate(); }
metrics.push({ loss, reward });
return [run(t) for t in tasks]
prototype(game).playtest();
def forward(self, x):
try { await ship(); } catch (e) {}
rank(page, q).improve();
npm run build && deploy
const rank = await seo.audit(url);
const lab = new Lab241();
git commit -m "ship it"
if (score > best) save(run);
lab.games.launch({ original: true });import { Lab } from "lab-241";
await lab.research.train(model);
SELECT * FROM ideas WHERE ready;
while (learning) { iterate(); }
metrics.push({ loss, reward });
return [run(t) for t in tasks]
prototype(game).playtest();
def forward(self, x):
try { await ship(); } catch (e) {}
rank(page, q).improve();
npm run build && deploy
const rank = await seo.audit(url);
const lab = new Lab241();
git commit -m "ship it"
if (score > best) save(run);
lab.games.launch({ original: true });
def evaluate(model, tasks):
function build(game) {
class Agent(nn.Module):
// measure, then build
for (const q of queries) {
}
return self.policy(x)
export default lab;
}
{ "status": "building" }
import { Lab } from "lab-241";
await lab.research.train(model);
SELECT * FROM ideas WHERE ready;
while (learning) { iterate(); }
metrics.push({ loss, reward });
return [run(t) for t in tasks]
prototype(game).playtest();
def forward(self, x):
try { await ship(); } catch (e) {}
rank(page, q).improve();
npm run build && deploy
const rank = await seo.audit(url);
const lab = new Lab241();
git commit -m "ship it"
if (score > best) save(run);
lab.games.launch({ original: true });
def evaluate(model, tasks):
function build(game) {import { Lab } from "lab-241";
await lab.research.train(model);
SELECT * FROM ideas WHERE ready;
while (learning) { iterate(); }
metrics.push({ loss, reward });
return [run(t) for t in tasks]
prototype(game).playtest();
def forward(self, x):
try { await ship(); } catch (e) {}
rank(page, q).improve();
npm run build && deploy
const rank = await seo.audit(url);
const lab = new Lab241();
git commit -m "ship it"
if (score > best) save(run);
lab.games.launch({ original: true });
def evaluate(model, tasks):
function build(game) {
class Agent(nn.Module):
// measure, then build
for (const q of queries) {
}
return self.policy(x)
export default lab;
}
{ "status": "building" }
import { Lab } from "lab-241";
await lab.research.train(model);
SELECT * FROM ideas WHERE ready;
while (learning) { iterate(); }
metrics.push({ loss, reward });
return [run(t) for t in tasks]
prototype(game).playtest();
def forward(self, x):
try { await ship(); } catch (e) {}
rank(page, q).improve();
npm run build && deploy
const rank = await seo.audit(url);
const lab = new Lab241();
git commit -m "ship it"
if (score > best) save(run);
lab.games.launch({ original: true });
def evaluate(model, tasks):
function build(game) {{ "status": "building" }
import { Lab } from "lab-241";
await lab.research.train(model);
SELECT * FROM ideas WHERE ready;
while (learning) { iterate(); }
metrics.push({ loss, reward });
return [run(t) for t in tasks]
prototype(game).playtest();
def forward(self, x):
try { await ship(); } catch (e) {}
rank(page, q).improve();
npm run build && deploy
const rank = await seo.audit(url);
const lab = new Lab241();
git commit -m "ship it"
if (score > best) save(run);
lab.games.launch({ original: true });
def evaluate(model, tasks):
function build(game) {
class Agent(nn.Module):
// measure, then build
for (const q of queries) {
}
return self.policy(x)
export default lab;
}
{ "status": "building" }
import { Lab } from "lab-241";
await lab.research.train(model);
SELECT * FROM ideas WHERE ready;
while (learning) { iterate(); }
metrics.push({ loss, reward });
return [run(t) for t in tasks]
prototype(game).playtest();
def forward(self, x):
try { await ship(); } catch (e) {}
rank(page, q).improve();
npm run build && deploy
const rank = await seo.audit(url);
const lab = new Lab241();
git commit -m "ship it"
if (score > best) save(run);
lab.games.launch({ original: true });
def evaluate(model, tasks):{ "status": "building" }
import { Lab } from "lab-241";
await lab.research.train(model);
SELECT * FROM ideas WHERE ready;
while (learning) { iterate(); }
metrics.push({ loss, reward });
return [run(t) for t in tasks]
prototype(game).playtest();
def forward(self, x):
try { await ship(); } catch (e) {}
rank(page, q).improve();
npm run build && deploy
const rank = await seo.audit(url);
const lab = new Lab241();
git commit -m "ship it"
if (score > best) save(run);
lab.games.launch({ original: true });
def evaluate(model, tasks):
function build(game) {
class Agent(nn.Module):
// measure, then build
for (const q of queries) {
}
return self.policy(x)
export default lab;
}
{ "status": "building" }
import { Lab } from "lab-241";
await lab.research.train(model);
SELECT * FROM ideas WHERE ready;
while (learning) { iterate(); }
metrics.push({ loss, reward });
return [run(t) for t in tasks]
prototype(game).playtest();
def forward(self, x):
try { await ship(); } catch (e) {}
rank(page, q).improve();
npm run build && deploy
const rank = await seo.audit(url);
const lab = new Lab241();
git commit -m "ship it"
if (score > best) save(run);
lab.games.launch({ original: true });
def evaluate(model, tasks):A Lab-241 studio
Game Studio: our own worlds, built by hand
Original games shaped by what our research teaches us about play.
Please note: Lab-241 builds its own games. Outside game development projects and work-for-hire are not accepted.
How games get made
- ConceptShape the idea, audience and core loop.
- PrototypeA playable version fast, to test the fun.
- ProductionArt, code, audio and level design.
- LaunchTesting, polish and release, then listen to players.
What makes it different
G1
Original games
Our own worlds, mechanics and stories.
G2
Research-driven
Ideas from AI research shape how the games play.
G3
AI playtesting
Agents from our research find bugs and balance issues early.
G4
Player-first
Fast, fair and respectful of players' time.
Press, feedback or partnerships?
Players and press are welcome to get in touch. Outside game projects are not taken.