Available Now
Book a demo and get early access. Free trial!
In the early days of discrete-event simulation, we wrote everything by hand. Tools like simlib
—a C-based simulation library—taught us how to manage event queues, model delays, and accumulate stats. But they also taught us something more valuable: Simulation is about control over time, behavior, and outcomes.
Today, that control still matters—but it doesn’t have to come from manual coding. With Python, USD, and AI copilots like those built into Champion, engineers are shifting from low-level scripting to high-level orchestration.
⚙️ Classic simlib: Functions That Defined Simulation Control
Let’s take a quick look at the essential simlib
functions and what they did:
| `simlib` Function | Purpose |
|-------------------------------|-------------------------------------------------------------|
| `init_simlib()` | Initializes simulation, clock, lists, and metadata |
| `list_file(option, list)` | Inserts a record into a list (e.g., a queue or event list) |
| `list_remove(option, list)` | Removes a record from a list into a transfer array |
| `timing()` | Advances sim time and gets next event type |
| `event_schedule(t, type)` | Schedules a new event into the future |
| `event_cancel(type)` | Cancels a pending event of given type |
| `sampst(val, var)` | Samples discrete-time values (e.g., delay time) |
| `timest(val, var)` | Samples continuous-time values (e.g., number in queue) |
| `filest(list)` | Tracks average # of records in a list over time |
| `expon(mean, stream)` | Samples from an exponential distribution |
| `random_integer(p[], s)` | Samples from a discrete distribution |
Python (especially with SimPy
, heapq
, and asyncio
) makes these ideas simpler, cleaner, and reusable. Here's a mapping:
| simlib Concept | Python Equivalent |
|--------------------|---------------------------------------------------------------|
| Event list | `heapq` or `queue.PriorityQueue` |
| Transfer array | Plain Python `dict` or object |
| Timing function | `simpy.Environment().timeout()` or `asyncio.sleep()` |
| Distributions | `numpy.random.exponential()`, `random.choices()` |
| Stats accumulators | `pandas.DataFrame`, custom loggers |
import heapq
import random
sim_time = 0
event_list = []
def schedule_event(time, event_type):
heapq.heappush(event_list, (time, event_type))
def run_simulation():
global sim_time
while event_list:
sim_time, event_type = heapq.heappop(event_list)
handle_event(event_type)
def handle_event(event_type):
print(f"[{sim_time:.2f}] Handling event type {event_type}")
In Champion, we’ve taken the foundations of simlib—and rebuilt them for simulation engineers working with:
But instead of writing list_file()
or event_schedule()
manually, you simply tell the AI what you want to happen.
Prompt: “Place 3 boxes on the belt every 2 seconds. Remove them after they reach the edge.”
Here’s how Champion breaks this down internally using AI and USD structure awareness:
| Classical simlib Concept | Champion's Agentic AI Equivalent |
|----------------------------------|---------------------------------------------------------------------|
| `list_file(INCREASING)` | Auto-generates `AddPrim` and `SetTransform` in USD |
| `event_schedule(t, type)` | Schedules `Omni.timeline.schedule_task()` via Python API |
| `timing()` | Internally handled by Omniverse's real-time loop |
| `transfer[]` | Internal memory passed between AI agents |
| `sampst()` and `timest()` | Automatically tracked via sensors and AI logging agents |
omni.isaac
, omni.usd
, or carb.timeline
All of this used to be done manually in simlib using init_simlib
, timing
, event_schedule
, and sampst
. Now, it’s driven by language → logic → Python → USD.
Here's a side-by-side table comparing core simlib
functions with their equivalents in Champion's agentic AI system.
| # | `simlib` Function | Champion Agentic Equivalent |
|----|-------------------------------|----------------------------------------------------------------------|
| 1 | `init_simlib()` | USD scene parsing + sim init agent |
| 2 | `list_file(option, list)` | AI places USD prims with spatial logic |
| 3 | `list_remove(option, list)` | AI removes prims or toggles visibility |
| 4 | `timing()` | Handled by internal sim clock |
| 5 | `event_schedule(time, type)` | AI auto-schedules via prompt intent |
| 6 | `event_cancel(type)` | AI deletes/overrides scheduled actions |
| 7 | `sampst(value, var)` | Auto-logged delay metrics via sensors |
| 8 | `timest(value, var)` | Auto-logged continuous stats via USD agents |
| 9 | `filest(list)` | Tracked object count via USD timeline hooks |
| 10 | `expon(mean, stream)` | Sampled from internal sim stream (numpy / Isaac RNG) |
| 11 | `random_integer(p[], s)` | AI samples discrete choices via logic layer |
| Legacy `simlib` Approach | Champion’s Agentic USD Approach |
|-----------------------------------|------------------------------------------------|
| Hand-written loops | Prompt-based scene logic |
| Hardcoded physics assumptions | AI interprets domain logic |
| Discrete queues and events | 3D spatial and temporal flow |
| C with manual memory mgmt | Python with dynamic USD graph |
| Per-simulation custom coding | Reusable prompt-to-simulation agents |
Want to simulate:
Let Champion’s AI agents handle the boring bits.
Just bring the model. We’ll handle the simulation logic.
👉 See how it works at champion3d.io
Book a demo and get early access. Free trial!