The idea for AWGS-Core arose from a simple yet unsettling question:
What if a simulated world weren't made of "things," but rather of constantly interacting processes?
Most traditional simulation engines represent static entities: objects, NPCs, isolated variables. However, when studying complex systems, from ecology to economics, a clear pattern emerges: what matters is not the elements themselves, but the dynamic relationships between them.
This idea intersected with my personal interests in:
dynamic systems emergent simulation computational ontologies anticipatory models artificial intelligence applied to semantic structure
From this convergence, AWGS-Core emerged as an experiment: to build a system where natural language could be directly transformed into a dynamic world.
What it does
AWGS-Core transforms text descriptions into simulated worlds that evolve over time.
Starting with a written idea, the system can generate:
an environment with dynamic processes rules that change dynamically interactions between elements and possible world evolutions
In short: it transforms ideas into living simulations. Challenges We Ran Into
One of the main challenges was that natural language is inherently ambiguous and difficult to structure consistently. As the system grew, its complexity also increased rapidly, making it harder to maintain stability. Another significant challenge was achieving coherence between the different modules, as each part of the system interpreted information slightly differently. Furthermore, striking a balance between system control and its capacity for free and emergent behavior was a critical design point. Finally, the reliance on external tools to interpret the text also added limitations at certain stages of development.
Achievements
One of the greatest achievements was transforming simple text into functional simulations that evolve over time. A process-based system was also designed instead of a traditional object-based one, allowing for a more dynamic way of representing the world. A fully modular architecture was successfully built, facilitating expansion and improvement. Additionally, the system can continuously evolve based on its own rules, and a layer was added that allows for imagining possible future scenarios based on the current state.
What we learned
During development, it became clear that it is more natural to model complex systems as processes rather than static objects. It was also understood that language is not exact, but interpretive, which directly affects how systems that depend on it are built. Complex systems tend to function better when not everything is completely defined from the outset, allowing for a degree of emergence. In general, simulation is closer to understanding dynamic relationships between elements than to programming fixed rules.
Log in or sign up for Devpost to join the conversation.