userchasm logo
userchasm

Diesel for Culture Engineering

Simulation OS for Dreamtime Physics

userchasm lets creative builders spin up, run, and share containerized worlds — fictional and scientific, using real physics solvers. Our new language, called Diesel DSL, permits expressive descriptions of scenes, powers, and interactions. Run accurate simulations for seemingly impossible worlds.

Early access includes Diesel DSL playground

Introducing Diesel DSL

Compose bodies, fields, forces, and collision rules in a few lines. Diesel is declarative and expressive; our solvers translate it to physics graphs, constraints, and integration steps.

1
2
3
4
5
6
7
8
9
scene "Chasm Entry"
system.load : dreamtime.physics
system.seed : visitor.id
body "Observer" mass 76kg
field time.refraction : τ0.12
field potential.ψ : ϟ0.44
mode perceptual : +3
couple "Observer" → chasm(0)
note "Chasm online. Define further world sim logic in Diesel"

Simulate behaviors from any world — fictional, scientific, or both.

Research-driven worldbuilding

  • Build simulation modules from real science blended with imagination.
  • Define dynamic systems from atoms to automations with intuitive tools.
  • Create consistent worlds backed by modal logic and physical inference.

Intelligent physics engine

  • Use a real scientific engine, not a game-engine approximation stack.
  • Maintain your engine's intelligence using vector graphs to store reference corpora of any domain.
  • Define your world in Diesel; LLMs + solvers fill in the technicalities.

Compute-first simulation

  • Modern games waste ~72% of processing power on visuals alone.
  • Render simulations with AI video only when necessary.
  • Push more of your world into high-fidelity simulation instead of GPU noise.

Physics-grade fidelity

  • Make use of MuJoCo-grade solvers tuned for fantastical constraints, with more heavy-duty solvers available on-demand.
  • Diesel scenes compile to rigid bodies, fields, and interactions, ensuring high-quality scene evolution.

Diesel describes behaviors. Our physics solvers simulate them.

Example cinematic Diesel snippets across physics, arcana, sci-fi, biology, meta, and combat.

ℏ∇Tensor Shear Bloom

A precision physics burst that releases a controlled shear cascade, redistributing stress across the arena in fractal blooms.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
technique "Tensor Shear Bloom" domain physics.major:
struct ShearBloomℏ {
gradient: Float
bloom_radius: Float
dissipation: Float
}
bloomℏ = ShearBloomℏ{
gradient: 0.88,
bloom_radius: 4.2m,
dissipation: 0.33
}
# Metric distortion
field.metric∇.shear = bloomℏ.gradient
field.metric∇.radius = bloomℏ.bloom_radius
field.metric∇.decay = bloomℏ.dissipation
# Stress redistribution
stress.fieldσ["arena"] ↓ 0.41
stress.pocketσ["target"]↑ 0.29
# Modal coupling
mode.elastic.major +1
mode.rupture.minor −1
chasm.echoτ.frequency = 12.4Hz
end.technique
✶ϴAstral Locus Thrum

An arcane focal maneuver that pins an astral locus in space, turning ambient emotion into directed resonance.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
invocation "Astral Locus Thrum" domain arcane.major:
struct Locus✶ {
radius: Float
resonance: Float
bleed: Float
}
locus✶ = Locus✶{
radius: 2.0m,
resonance: 0.74,
bleed: 0.18
}
# Anchor the locus
arcane.locusϴ.radius = locus✶.radius
arcane.locusϴ.resonance = locus✶.resonance
arcane.locusϴ.bleed = locus✶.bleed
# Emotional field transduction
field.emotiveϕ.density → "coherent"
field.emotiveϕ.amplitude↑ 0.33
# Threads of belief
strand.faith["allies"] ↑ 0.27
strand.doubt["enemy"] ↓ 0.22
chasm.humψ.key = "minor-aether"
end.invocation
⧊ΛRelic-Drive Rail Shift

A sci-fi displacement burst that phases the user along a rail of precomputed paths, snapping them to the safest viable timeline.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
ability "Relic-Drive Rail Shift" domain sciFi.major:
struct Rail⧊ {
lanes: Int
snap_latency: Float
risk_tolerance: Float
}
rail⧊ = Rail⧊{
lanes: 5,
snap_latency: 0.06s,
risk_tolerance: 0.28
}
# Predictive rail mapping
timeline.railΛ.count = rail⧊.lanes
timeline.railΛ.latency = rail⧊.snap_latency
timeline.railΛ.risk = rail⧊.risk_tolerance
# Path scoring
for lane in timeline.railΛ:
lane.score = eval.survival["user"] * (1.0 - rail⧊.risk_tolerance)
# Phase shift along best lane
user.phaseΔ.position → lane.best.path
user.phaseΔ.jitter = 0.004s
strand.fate["user"] → "rail-locked" by 0.33
end.ability
μ✺Mycelial Pulse Mantle

A biological defense that spreads a living mycelial layer across the user, routing damage into regenerative growth.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
action "Mycelial Pulse Mantle" domain bio.major:
struct MycelMantleμ {
spread_rate: Float
absorb_ratio: Float
regen_gain: Float
}
mantleμ = MycelMantleμ{
spread_rate: 0.44,
absorb_ratio: 0.62,
regen_gain: 0.27
}
# Colonization across body map
bio.myceliumζ.coverage ↑ mantleμ.spread_rate
bio.myceliumζ.absorption = mantleμ.absorb_ratio
# Damage routing
impact.damage["user"] → "biomass"
impact.redirect["vital"] ↓ 0.38
# Regenerative response
bio.regenΩ.rate ↑ mantleμ.regen_gain
bio.regenΩ.bias → "scar-to-armor"
chasm.rootnetη.depth = 1.8m
end.action
⧖τTimeline Fork Kernel

A meta-simulation primitive that spawns controlled timeline forks, scoring each branch before committing reality.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
kernel "Timeline Fork Kernel" domain meta.major:
struct Fork⧖ {
branches: Int
horizon: Float
entropy_cap: Float
}
fork⧖ = Fork⧖{
branches: 3,
horizon: 2.4s,
entropy_cap: 0.52
}
# Fork generation
timeline.forkτ.count = fork⧖.branches
timeline.forkτ.horizon = fork⧖.horizon
timeline.forkτ.entropy ≤ fork⧖.entropy_cap
# Branch evaluation
for branch in timeline.forkτ:
branch.score["user.survival"] = eval.outcome(branch)
branch.score["style.factor"] = eval.flair(branch)
# Commit best-fit reality
reality.commit branch.max(score["user.survival"] + score["style.factor"])
strand.memory["other-branches"] → "dream-residue" by 0.22
end.kernel
✕ϟUmbral Impact Pivot

A brutal combat technique that hijacks incoming momentum, flipping it through an umbral axis and returning amplified force.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
move "Umbral Impact Pivot" domain combat.major:
struct Pivot✕ {
capture_window: Float
inversion_gain: Float
bleed_through: Float
}
pivot✕ = Pivot✕{
capture_window: 0.09s,
inversion_gain: 1.44,
bleed_through: 0.18
}
# Capture incoming strike
impact.windowΔ["user"] = pivot✕.capture_window
impact.capture["enemy"] → "vector-store"
# Umbral inversion
umbra.axisϟ.orientation = "counterspin"
umbra.axisϟ.gain = pivot✕.inversion_gain
# Return force
impact.return["enemy"] = impact.stored * umbra.axisϟ.gain
impact.bleed["user"] = pivot✕.bleed_through
strand.fear["enemy"] ↑ 0.41
strand.steady["user"] ↑ 0.22
end.move

A simulation platform for culture.
Enter your userchasm.

Join the early access list.

No spam. We share userchasm updates and Diesel coding tips.