In this page
Python library
GreyCat is often compared to Python, as both are programming languages.
However, GreyCat’s primary target is SQL, the de facto language for querying databases.
Unlike garbage-collected languages such as Python or JavaScript, GreyCat scales to billions of persisted data nodes without performance degradation.
That said, as a niche project, GreyCat lacks readily available libraries, particularly for emerging use cases like LLM integration.
Bindings help bridge this gap, but clear boundaries must be defined for each component’s responsibilities.
Component Interaction
GreyCat WebComponents JS
⟷ GreyCat Server HTTP API
⟷ GreyCat Fn Stateful
⟷ Python Fn Stateless
In Summary
We aim to enable stateless Python function calls from GreyCat code.
Usage
Add python library as any other native libraries using: greycat
@library("std", "7.0.1704-testing");
@library("python", "7.0.172-testing");
fn main(){
pprint("py_runtime_version: ${Python::get_version()}");
}
The GreyCat Python library comes with a full python interpreter 3.12 embedded and not related to the one of the system
[root@dth4 v7py]# tree bin
bin
├── greycat
├── pip3
└── python3
Let’s simply run it and print the available version
[v7py]# ./bin/greycat run
py_runtime: 3.12.9 (main, Mar 6 2025, 00:44:11) [GCC 12.3.1 20230508 (Red Hat 12.3.1-1)]
Bind python function
native fn hi_python(v: String): String;
fn main(){
pprint(hi_python("gc_py_lib"));
}
Then defines in a project.py
from greycat import gc_native
@gc_native("project::hi_python")
def hi_python(v: str) -> str:
return f"Hello, {v}!"
Let’s simply run it
[v7py]# ./bin/greycat run
Hello, gc_py_lib!
Dependencies
To avoid known hell of python deps we have hard wired pip to install everything locally, the venv way
As classic pip requirements.txt
is the sole source of definition for python deps
numpy==1.26.4
pandapower==3.0.0
Then install deps using the following commands:
./bin/pip3 install -r requirements.txt
Packages are installed in
./lib/python/lib/python3.12/site-packages
Now all pandapower functions are available in project.py
Codegen, GreyCat-side
type Person {
name: String;
birthday: time;
}
native fn get_persons(map: Map<String, time>): Array<Person>;
native fn map_persons(persons: Array<Person>): Map<String, time>;
fn main() {
var map = Map<String, time>{};
map.set("Doe", 0_time);
map.set("Ada", time::parse("1815-12-10T00:00:00", null));
var persons = get_persons(map);
pprint(persons);
pprint(map_persons(persons));
}
Generate Python bindings in current directory:
greycat codegen --target=python .
Codegen, Python-side
native fn get_persons(map: Map<String, time>): Array<Person>;
native fn map_persons(persons: Array<Person>): Map<String, time>;
Then in project.py:
from greycat_types import *
@gc_native("project::get_persons")
def get_persons(map: core.Map[str, core.time]) -> core.Array[project.Person]:
persons: core.Array[project.Person] = core.Array.create()
for name, birthday in map.items():
persons.append(project.Person.create(name, birthday))
return persons
@gc_native("project::map_persons")
def map_persons(persons: core.Array[project.Person]) -> core.Map[str, core.time]:
map: core.Map[str, core.time] = core.Map.create()
person: project.Person
for person in persons:
map[person.name()] = person.birthday()
return map
Codegen, GreyThon (or PyCat, pick your poison)
$ greycat run
Array<Person> {
Person {
name: "Ada",
birthday: '1815-12-10T00:00:00Z'
},
Person {
name: "Doe",
birthday: '1970-01-01T00:00:00Z'
}
}
Map<String,time> {
"Ada": '1815-12-10T00:00:00Z',
"Doe": '1970-01-01T00:00:00Z'
}
Availability
- mac arm64
- linux x64
- linux arm64
- windows still under dev
Drawbacks
Python takes a very different approach internally compared to GreyCat:
-
Python uses a Global Interpreter Lock (GIL) (single-threaded, cooperative scheduler, released during math kernel execution)
-
GreyCat uses a share-nothing architecture (fully independent threaded execution, fusion happens at transaction commits)
Injecting Python functions introduces major performance bottlenecks and makes packaging tricky.
Thus, use it with caution! Python functions can become technical debt when it comes to scaling.
That said, prioritizing features and leveraging GreyCat aims to keep all web development and data models aligned.
Do we expect this to change?
We studied Python’s GIL, especially the sub-interpreter proposal in recent Python versions.
However, this impacts the wide variety of existing libraries—such as NumPy—which are effectively incompatible…
Python’s major strength, its library ecosystem, is also a major drawback, as upgrading them can take decades.