For 11 years I have been experimenting with a multi-paradigm language designed to describe NPC behavior.
Main objective: to create a language that is both highly expressive and human-readable.
This is achieved through the use of useful but rarely applied techniques (for example, fuzzy logic or logic programming). These techniques are implemented via dedicated syntactic constructs, which make the language more compact and expressive.
Today I would like to demonstrate the current capabilities of my project, called SymOntoClay.
For many years I focused more on programming than on communication. Therefore, this publication also serves as the first formal introduction of SymOntoClay to the wider Internet community.
Brief History
The history of SymOntoClay began with the idea of creating an Action/RPG with elements of a social simulator. In essence, a miniature Fallout-style game about survival in a military conflict zone. As a programmer, I decided to focus as much as possible on the software implementation first, and only later assemble a team.
During the process of developing the game concept and the initial attempts at implementation, I recalled rule-based systems. Primarily Prolog and expert systems with logical inference based on facts and rules. I thought it would be convenient to program at least part of the NPC logic in this way.
Gradually, the idea of applying logical inference within imperative languages such as C++ or C# began to seem more appealing than game development itself. More precisely, it seemed more appealing than the process of team building and communication.
Thus, in May 2014, I had the "crazy" idea to create my own programming language, one that would combine logic programming with imperative code. At the same time, I wanted to embed directly into the syntax a number of useful but rarely applied concepts in industrial languages. For example, I considered adding fuzzy logic, among many other features.
As a result, I never created my miniature Action/RPG, but instead began work on what was then an unnamed project, which I now call SymOntoClay (Symbolic ontological clay).
Initially, I believed I could create the language specification within a few months and implement it within a year. However, as often happens, the project took somewhat longer (11 years) and shows no intention of ending.
During all this time, I never published a single post or article about it. I enjoy programming significantly more than communication. Moreover, my "inner perfectionist" wanted to present to the world only a completed, ideal, and fully "polished" project.
Now, after 11 years, I have finally decided to talk about it. Over these years, I realized that waiting for the perfect moment to publish is meaningless. I asked myself: "How much longer should I wait? Another 11 years?" This led to the idea of publishing SymOntoClay as it is - living, evolving, imperfect, with legacy rings accumulated over time.
Current State of the Project
Over 11 years, many features have been implemented in the project, but all of them allow only the description of very simple NPC behavior. This is due to the fact that I enjoy experimenting with syntax much more than creating games. Experiments with applying SymOntoClay in Unity were conducted on a residual basis - solely to verify the basic functionality of the concepts.
The project code is available on GitHub under the MIT license: github.com/Symontoclay
More details about SymOntoClay can be found on the project website.
The development of the idea is described in the project White Paper.
The documentation is not uniformly developed. Only the language specification is fully elaborated and up to date. Usage examples and Getting Started are somewhat less detailed and current, but still sufficient for now. The remaining documentation requires expansion and refinement, which remains one of the immediate tasks.
The project YouTube channel is currently empty. However, I plan to actively work on its content in the near future.
The project does not yet have a community. This is my first attempt to present the project outside of personal notes. Previously, I only posted a video demonstrating the operation of an early prototype in the Indie Game Developer group on Facebook, but I did not promote the project itself.
Example DSL for Defining a Linguistic Variable
linvar `degree of membership` for range [0, 1]
{
constraints:
for inheritance;
terms:
minimal = L(0, 0.1);
low = Trapezoid(0, 0.05, 0.3, 0.45);
middle = Trapezoid(0.3, 0.4, 0.6, 0.7);
high = Trapezoid(0.55, 0.7, 0.95, 1);
maximal = S(0.9, 1);
}
Roadmap: Where I'd Like to Go Next
SymOntoClay is still far from the state that would fully satisfy me. There is still a significant amount of work ahead.
Main direction of work: to create a minimally playable demo scene. For this, I plan to finalize my implementation of HTN and then fully engage in programming within Unity.
Debugging code in a custom DSL is a major difficulty that significantly slows down its use. Therefore, I plan to develop a debugger, profiler, and similar tools.
Basic functionality such as syntax highlighting in VS Code or at least in Notepad++ has not yet been implemented. A full language server is also missing. Time must be allocated to implement these features.
Documentation is an important part of the project, which I often postpone. First of all, the architecture and key aspects of the engine need to be described. The documentation contains very few diagrams - only one, which is outdated. This must be corrected.
The project YouTube channel should be filled with videos containing short demonstrations of demo scenes with characters controlled by SymOntoClay.
Finally, I plan to publish articles about my project and attempt to create a community on Discord.
Conclusion
This is the first publication about my project on the wider Internet. The project has finally moved beyond personal notes.
Thank you for reading to the end!
Top comments (2)
I truly admire your dedication to this project, which I hope continues to gain traction now you have spoken about it. I look forward to reading more updates in the future!
Thank you very much for your kind words!
I will continue developing the project. I hope that in the foreseeable future it will be possible to create something of practical use with it.
Publishing the project was a big step for me. I hope this will give a strong impulse to its development.
I will try to share updates as the project evolves.