A process-based discrete-event simulation framework. Use for modeling queuing systems, supply chains, manufacturing processes, network simulation, project management, and any system where events occur at specific points in time. Load when working with discrete event simulation, process modeling, resource allocation, virtual time, simpy.Environment, simpy.Resource, or event-driven simulation.
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
A direct command skips the review prompt. Inspect the source before running it.
A process-based discrete-event simulation framework. Use for modeling queuing systems, supply chains, manufacturing processes, network simulation, project management, and any system where events occur at specific points in time. Load when working with discrete event simulation, process modeling, resource allocation, virtual time, simpy.Environment, simpy.Resource, or event-driven simulation.
version
4.1
license
MIT
SimPy - Discrete Event Simulation
SimPy allows you to model real-world processes as Python generators. Components in SimPy (like customers, cars, or data packets) are "processes" that interact with each other and with limited "resources" (like servers, parking spots, or bandwidth).
When to Use
Modeling queuing systems (Bank tellers, call centers, hospital emergency rooms)
Simulating supply chains and logistics (Warehouses, transport networks)
SimPy uses an internal clock starting at 0. Time moves forward only when an event is processed. Between events, "nothing" happens, so simulating 100 years takes seconds if only a few events occur.
Processes as Generators
Processes are standard Python functions using yield. When a process yields an event, SimPy suspends it until that event occurs.
Resources
Three types of shared objects:
Resource: Limited number of slots (e.g., a counter)
Container: For bulk matter (e.g., a gas tank, RAM)
Store: For distinct objects (e.g., a buffer of messages)
Quick Reference
Installation
pip install simpy
Standard Imports
import simpy
import random
Basic Pattern - A Simple Process
import simpy
defclock(env, name, tick):
whileTrue:
print(f"{name} at {env.now}")
# 'yield' tells SimPy to wait for this eventyield env.timeout(tick)
# 1. Create Environment
env = simpy.Environment()
# 2. Add Process
env.process(clock(env, 'Fast', 0.5))
env.process(clock(env, 'Slow', 1.0))
# 3. Run for 2 units of virtual time
env.run(until=2.1)
Critical Rules
✅ DO
Use yield env.timeout(n) - This is the only way to advance time for a process. Never use time.sleep().
Use with resource.request() as req: - This ensures a resource is automatically released even if the process is interrupted or fails.
Set a random seed - Always use random.seed(42) for reproducible simulations.
Pass the env object - Every process and resource needs a reference to the environment to track time.
Use env.run(until=...) - Always define a stopping condition, otherwise a while True simulation will run forever.
Collect data in lists - Store timestamps and event details in external lists for post-simulation analysis (e.g., with Pandas).
❌ DON'T
Use real-world time - simpy is for virtual time. env.now is your only clock.
Modify the environment directly - Interact with it only through processes and events.
Forget to yield - If you don't yield an event inside a loop, you create an infinite loop at the same instant in virtual time, hanging the simulation.
Block the event loop - Heavy CPU calculations inside a process should be rare; they "stop" the virtual clock of the entire simulation while the CPU works.
Anti-Patterns (NEVER)
import simpy
import time
# ❌ BAD: Using real sleepdefbad_process(env):
time.sleep(1) # This stops the REAL clock, but virtual time doesn't move!yield env.timeout(1)
# ✅ GOOD: Use virtual timeoutdefgood_process(env):
yield env.timeout(1) # Moves virtual clock forward instantly# ❌ BAD: Infinite loop without yielding# def hang_forever(env):# while True:# x = 1 + 1 # No yield = simulation clock stuck at current env.now# ❌ BAD: Manual resource release (Dangerous)defrisky_request(env, res):
req = res.request()
yield req
# If something fails here, the resource is never released
res.release(req)
# ✅ GOOD: Using context managerdefsafe_request(env, res):
with res.request() as req:
yield req
# Resource automatically released when exiting 'with'
Resources and Queues (simpy.Resource)
Managing Shared Capacity
defcar(env, name, bcs, driving_time, charge_time):
# Simulate driving to the stationyield env.timeout(driving_time)
print(f'{name} arriving at {env.now}')
# Request one of the charging spotswith bcs.request() as req:
yield req
print(f'{name} starting to charge at {env.now}')
yield env.timeout(charge_time)
print(f'{name} leaving at {env.now}')
env = simpy.Environment()
# Battery Charging Station with 2 spots
bcs = simpy.Resource(env, capacity=2)
for i inrange(4):
env.process(car(env, f'Car {i}', bcs, i*2, 5))
env.run()
Advanced Resources: Containers and Stores
Containers (Liquids/Bulk)
# Modeling a gas station tank
gas_tank = simpy.Container(env, capacity=1000, init=500)
defrefuel(env, gas_tank):
yield gas_tank.put(400) # Add fueldefcar(env, gas_tank):
yield gas_tank.get(40) # Consume fuel
In systems where some events are more important (e.g., critical patients), use PriorityResource.
res = simpy.PriorityResource(env, capacity=1)
with res.request(priority=0) as req: # Lower number = higher priorityyield req
Monitoring Large Simulations
Avoid printing to the console in high-speed simulations. Instead, use a data collection list and process it with NumPy/Pandas after the env.run() finishes.
Common Pitfalls and Solutions
The "Stuck Process"
If your code reaches a logic branch where no yield occurs in a while True loop, SimPy freezes.
# ❌ Problem:deflogic_error(env):
whileTrue:
if condition:
yield env.timeout(1)
# Else? If condition is false, we loop forever at same time point!# ✅ Solution:deflogic_fixed(env):
whileTrue:
if condition:
yield env.timeout(1)
else:
yield env.timeout(0.1) # Or some default wait
Multiple Environments
Never mix objects (Resources, Processes) from different environments. Every component must belong to the same simpy.Environment() instance.
Interruption Timing
When interrupting a process, the interrupt happens at the current virtual time. Be careful with what the interrupted process was yielding (it will receive a simpy.Interrupt exception).
Best Practices
Always use context managers for resources - with resource.request() as req: ensures proper cleanup
Set random seeds for reproducibility - Use random.seed(42) at the start of simulations
Collect data externally - Store event data in lists/dictionaries, not just print statements
Define clear stopping conditions - Always use env.run(until=...) with a specific time limit
Use virtual time only - Never mix time.sleep() or real-world time with SimPy
Test with small simulations first - Verify logic before running large-scale simulations
Document your processes - Clearly name processes and resources for debugging
Handle interruptions properly - Use try/except blocks when processes can be interrupted
SimPy turns Python's generator syntax into a powerful engine for modeling time and scarcity. It allows scientists and engineers to experiment with "What if?" scenarios for complex systems without the cost or risk of physical trials.
